###############################################################################

#

#	ReportLab Public License Version 1.0

#

#   Except for the change of names the spirit and intention of this

#   license is the same as that of Python

#

#	(C) Copyright ReportLab Inc. 1998-2000.

#

#

# All Rights Reserved

#

# Permission to use, copy, modify, and distribute this software and its

# documentation for any purpose and without fee is hereby granted, provided

# that the above copyright notice appear in all copies and that both that

# copyright notice and this permission notice appear in supporting

# documentation, and that the name of ReportLab not be used

# in advertising or publicity pertaining to distribution of the software

# without specific, written prior permission. 

# 

#

# Disclaimer

#

# ReportLab Inc. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,

# IN NO EVENT SHALL ReportLab BE LIABLE FOR ANY SPECIAL, INDIRECT

# OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

# PERFORMANCE OF THIS SOFTWARE. 

#

###############################################################################

#	$Log: paraparser.py,v $

#	Revision 1.26  2000/07/10 23:53:46  andy_robinson

#	Changed base of seqdefault tag to 0

#	Revision 1.25  2000/07/04 10:50:33  rgbecker

#	Sequencer fixes

#	

#	Revision 1.24  2000/06/19 11:14:03  andy_robinson

#	Global sequencer put in the 'story builder'.

#	

#	Revision 1.23  2000/06/13 04:11:49  aaron_watters

#	noted replication of XML markup comment between paraparser.py and paragraph.py

#	

#	Revision 1.22  2000/06/12 11:27:17  andy_robinson

#	Added Sequencer and associated XML tags

#	

#	Revision 1.21  2000/06/01 15:23:06  rgbecker

#	Platypus re-organisation

#	

#	Revision 1.20  2000/05/31 10:12:20  rgbecker

#	<bullet> xml tag added

#	

#	Revision 1.19  2000/05/26 09:49:23  rgbecker

#	Color fixes; thanks to J Alet

#	

#	Revision 1.18  2000/05/20 15:36:42  andy_robinson

#	Removed 1.5.2-style getattr call

#	

#	Revision 1.17  2000/05/16 14:28:55  rgbecker

#	Fixes/Changes to get testplatypus to work with new framework

#	

#	Revision 1.16  2000/05/15 12:15:29  rgbecker

#	CDATA handler added

#	

#	Revision 1.15  2000/05/13 16:04:06  rgbecker

#	made size alias of fontsize for <para>

#	

#	Revision 1.14  2000/05/11 14:05:17  rgbecker

#	Use reportlab.lib.xmllib

#	

#	Revision 1.13  2000/04/25 13:07:57  rgbecker

#	Added license

#	

import string

import re

from types import TupleType

import sys

import os

import copy

import reportlab.lib.sequencer

#try:

#	from xml.parsers import xmllib

#	_xmllib_newStyle = 1

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

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

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

	"""class ParaFrag contains the intermediate representation of string

	segments as they are being parsed by the XMLParser.

	"""

	def __init__(self,**attr):

		for k,v in attr.items():

			setattr(self,k,v)

	def clone(self,**attr):

		n = apply(ParaFrag,(),self.__dict__)

		if attr != {}: apply(ParaFrag.__init__,(n,),attr)

		return n

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

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

# The ParaFormatter will be able to format the following xml

# tags:

#	   < b > < /b > - bold

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

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

		A = self.getAttributes(attr,_fontAttrMap)

		apply(self._push,(),A)

	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

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

		else: 

			id = None

		output = self._seq.nextf(id)

		self.handle_data(output)

	def end_seq(self):

		pass

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

	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