#copyright ReportLab Inc. 2000

#see license.txt for license details

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

__doc__="""

Tables are created by passing the constructor a tuple of column widths, a tuple of row heights and the data in

row order. Drawing of the table can be controlled by using a TableStyle instance. This allows control of the

color and weight of the lines (if any), and the font, alignment and padding of the text.

None values in the sequence of row heights or column widths, mean that the corresponding rows

or columns should be automatically sized.

All the cell values should be convertible to strings; embedded newline '\\n' characters

cause the value to wrap (ie are like a traditional linefeed).

See the test output from running this module as a script for a discussion of the method for constructing

tables and table styles.

"""

from reportlab.platypus import *

from reportlab.lib.styles import PropertySet, getSampleStyleSheet

from reportlab.lib import colors

from reportlab.pdfbase import pdfmetrics

import operator, string

from types import TupleType, ListType, StringType

class CellStyle(PropertySet):

	defaults = {

		'fontname':'Times-Roman',

		'fontsize':10,

		'leading':12,

		'leftPadding':6,

		'rightPadding':6,

		'topPadding':3,

		'bottomPadding':3,

		'firstLineIndent':0,

		'color':colors.black,

		'alignment': 'LEFT',

		'background': (1,1,1),

		'valign': 'BOTTOM',

		}

class TableStyle:

	def __init__(self, cmds=None):

		self._cmds = cmds

		if cmds is None:

			self._cmds = []

	def add(self, *cmd):

		self._cmds.append(cmd)

	def __repr__(self):

		L = map(repr, self._cmds)

		import string

		L = string.join(L, "  \n")

		return "TableStyle(\n%s\n) # end TableStyle" % L

	def getCommands(self):

		return self._cmds

TableStyleType = type(TableStyle())

_SeqTypes = (TupleType, ListType)

def _rowLen(x):

	return type(x) not in _SeqTypes and 1 or len(x)

def _listCellGeom(V,w,s,W=None,H=None):

	aW = w-s.leftPadding-s.rightPadding

	t = 0

	w = 0

	for v in V:

		vw, vh = v.wrap(aW, 72000)

		if W is not None: W.append(vw)

		if H is not None: H.append(vh)

		w = max(w,vw)

		t = t + vh + v.getSpaceBefore()+v.getSpaceAfter()

	return w, t - V[0].getSpaceBefore()-V[-1].getSpaceAfter() 

class Table(Flowable):

	def __init__(self, data, colWidths=None, rowHeights=None, style=None,

				repeatRows=0, repeatCols=0, splitByRow=1):

		nrows = len(data)

		if len(data)==0 or type(data) not in _SeqTypes:

			raise ValueError, "Table must have at least 1 row"

		ncols = max(map(_rowLen,data))

		if not ncols:

			raise ValueError, "Table must have at least 1 column"

		if colWidths is None: colWidths = ncols*[None]

		elif len(colWidths) != ncols:

			raise ValueError, "Data error - %d columns in data but %d in grid" % (ncols, len(colWidths))

		if rowHeights is None: rowHeights = nrows*[None]

		elif len(rowHeights) != nrows:

			raise ValueError, "Data error - %d rows in data but %d in grid" % (nrows, len(rowHeights))

		self._nrows = nrows

		ncols = self._ncols = len(colWidths)

		for i in range(nrows):

			if len(data[i]) != ncols:

				raise ValueError, "Not enough data points in row %d!" % i

		self._rowHeights = self._argH = rowHeights

		self._colWidths = self._argW = colWidths

		self._cellvalues = data

		dflt = CellStyle('<default>')

		self._cellStyles = [None]*nrows

		for i in range(nrows):

			self._cellStyles[i] = [dflt]*ncols

		self._bkgrndcmds = []

		self._linecmds = []

		self._curweight = self._curcolor = self._curcellstyle = None

		self.repeatRows = repeatRows

		self.repeatCols = repeatCols

		self.splitByRow = splitByRow

		if style:

			self.setStyle(style)

	def __repr__(self):

		"incomplete, but better than nothing"

		r = self._rowHeights

		c = self._colWidths

		cv = self._cellvalues

		import pprint, string

		cv = pprint.pformat(cv)

		cv = string.replace(cv, "\n", "\n  ")

		return "Table(\n rowHeights=%s,\n colWidths=%s,\n%s\n) # end table" % (r,c,cv)

	def _calc(self):

		if hasattr(self,'_width'): return

		H = self._argH

		W = self._argW

		if None in H:

			H = H[:]	#make a copy as we'll change it

			self._rowHeights = H

			while None in H:

				i = H.index(None)

				V = self._cellvalues[i]

				S = self._cellStyles[i]

				h = 0

				for v, s, w in map(None, V, S, W):

					t = type(v)

					if t in _SeqTypes or isinstance(v,Flowable):

						if not t in _SeqTypes: v = (v,)

						if w is None:

							raise ValueError, "Flowables cell can't have auto width"

						dW,t = _listCellGeom(v,w,s)

						dW = dW + s.leftPadding + s.rightPadding

						if dW>w:

							raise "LayoutError", "Flowable %s (%sx%s points) too wide for cell (%sx* points)." % (v,dW,t,w)

					else:

						if t is not StringType:

							v = v is None and '' or str(v)

						v = string.split(v, "\n")

						t = s.leading*len(v)

					t = t+s.bottomPadding+s.topPadding

					if t>h: h = t	#record a new maximum

				H[i] = h

		if None in W:

			W = W[:]

			self._colWidths = W

			while None in W:

				i = W.index(None)

				f = lambda x,i=i: operator.getitem(x,i)

				V = map(f,self._cellvalues)

				S = map(f,self._cellStyles)

				w = 0

				d = hasattr(self,'canv') and self.canv or pdfmetrics

				for v, s in map(None, V, S):

					t = type(v)

					if t in _SeqTypes or isinstance(v,Flowable):

						raise ValueError, "Flowables cell can't have auto width"

					elif t is not StringType: v = v is None and '' or str(v)

					v = string.split(v, "\n")

					t = s.leftPadding+s.rightPadding + max(map(lambda a, b=s.fontname,

								c=s.fontsize,d=d.stringWidth: d(a,b,c), v))

					if t>w: w = t	#record a new maximum

				W[i] = w

		height = self._height = reduce(operator.add, H, 0)

		self._rowpositions = [height]	 # index 0 is actually topline; we skip when processing cells

		for h in H:

			height = height - h

			self._rowpositions.append(height)

		assert abs(height)<1e-8, 'Internal height error'

		width = 0

		self._colpositions = [0]		#index -1 is right side boundary; we skip when processing cells

		for w in W:

			width = width + w

			self._colpositions.append(width)

		self._width = width

	def setStyle(self, tblstyle):

		if type(tblstyle) is not TableStyleType:

			tblstyle = TableStyle(tblstyle)

		for cmd in tblstyle.getCommands():

			self._addCommand(cmd)

	def _addCommand(self,cmd):

		if cmd[0] == 'BACKGROUND':

			self._bkgrndcmds.append(cmd)

		elif _isLineCommand(cmd):

			self._linecmds.append(cmd)

		else:

			(op, (sc, sr), (ec, er)), values = cmd[:3] , cmd[3:]

			if sc < 0: sc = sc + self._ncols

			if ec < 0: ec = ec + self._ncols

			if sr < 0: sr = sr + self._nrows

			if er < 0: er = er + self._nrows

			for i in range(sr, er+1):

				for j in range(sc, ec+1):

					_setCellStyle(self._cellStyles, i, j, op, values)

	def _drawLines(self):

		for op, (sc, sr), (ec, er), weight, color in self._linecmds:

			if sc < 0: sc = sc + self._ncols

			if ec < 0: ec = ec + self._ncols

			if sr < 0: sr = sr + self._nrows

			if er < 0: er = er + self._nrows

			getattr(self,_LineOpMap.get(op, '_drawUnknown' ))( (sc, sr), (ec, er), weight, color)

		self._curcolor = None

	def _drawUnknown(self,	(sc, sr), (ec, er), weight, color):

		raise ValueError, "Unknown line command '%s'" % op

	def _drawGrid(self,	(sc, sr), (ec, er), weight, color):

		self._drawBox( (sc, sr), (ec, er), weight, color)

		self._drawInnerGrid( (sc, sr), (ec, er), weight, color)

	def _drawBox(self,	(sc, sr), (ec, er), weight, color):

		self._drawHLines((sc, sr), (ec, sr), weight, color)

		self._drawHLines((sc, er+1), (ec, er+1), weight, color)

		self._drawVLines((sc, sr), (sc, er), weight, color)

		self._drawVLines((ec+1, sr), (ec+1, er), weight, color)

	def _drawInnerGrid(self, (sc, sr), (ec, er), weight, color):

		self._drawHLines((sc, sr+1), (ec, er), weight, color)

		self._drawVLines((sc+1, sr), (ec, er), weight, color)

	def _prepLine(self, weight, color):

		if color != self._curcolor:

			self.canv.setStrokeColor(color)

			self._curcolor = color

		if weight != self._curweight:

			self.canv.setLineWidth(weight)

			self._curweight = weight

	def _drawHLines(self, (sc, sr), (ec, er), weight, color):

		self._prepLine(weight, color)

		scp = self._colpositions[sc]

		ecp = self._colpositions[ec+1]

		for rowpos in self._rowpositions[sr:er+1]:

			self.canv.line(scp, rowpos, ecp, rowpos)

	def _drawHLinesB(self, (sc, sr), (ec, er), weight, color):

		self._drawHLines((sc, sr+1), (ec, er+1), weight, color)

	def _drawVLines(self, (sc, sr), (ec, er), weight, color):

		self._prepLine(weight, color)

		srp = self._rowpositions[sr]

		erp = self._rowpositions[er+1]

		for colpos in self._colpositions[sc:ec+1]:

			self.canv.line(colpos, srp, colpos, erp)

	def _drawVLinesA(self, (sc, sr), (ec, er), weight, color):

		self._drawVLines((sc+1, sr), (ec+1, er), weight, color)

	def wrap(self, availWidth, availHeight):

		self._calc()

		#nice and easy, since they are predetermined size

		self.availWidth = availWidth

		return (self._width, self._height)

	def onSplit(self,T,byRow=1):

		'''

		This method will be called when the Table is split.

		Special purpose tables can override to do special stuff.

		'''

		pass

	def _cr_0(self,n,cmds):

		for c in cmds:

			c = tuple(c)

			(sc,sr), (ec,er) = c[1:3]

			if sr>=n: continue

			if er>=n: er = n-1

			self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])

	def _cr_1_1(self,n,repeatRows, cmds):

		for c in cmds:

			c = tuple(c)

			(sc,sr), (ec,er) = c[1:3]

			if sr>=0 and sr>=repeatRows and sr<n and er>=0 and er<n: continue

			if sr>=repeatRows and sr<n: sr=repeatRows

			elif sr>=repeatRows and sr>=n: sr=sr+repeatRows-n

			if er>=repeatRows and er<n: er=repeatRows

			elif er>=repeatRows and er>=n: er=er+repeatRows-n

			self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])

	def _cr_1_0(self,n,cmds):

		for c in cmds:

			c = tuple(c)

			(sc,sr), (ec,er) = c[1:3]

			if er>=0 and er<n: continue

			if sr>=0 and sr<n: sr=0

			if sr>=n: sr = sr-n

			if er>=n: er = er-n

			self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])

	def _splitRows(self,availHeight):

		h = 0

		n = 0

		lim = len(self._rowHeights)

		while n<lim:

			hn = h + self._rowHeights[n]

			if hn>availHeight: break

			h = hn

			n = n + 1

		if n<=self.repeatRows:

			return []

		if n==lim: return [self]

		repeatRows = self.repeatRows

		repeatCols = self.repeatCols

		splitByRow = self.splitByRow

		data = self._cellvalues

		#we're going to split into two superRows

		R0 = Table( data[:n], self._argW, self._argH[:n],

				repeatRows=repeatRows, repeatCols=repeatCols,

				splitByRow=splitByRow)

		#copy the styles and commands

		R0._cellStyles = self._cellStyles[:n]

		A = []

		# hack up the line commands

		for op, (sc, sr), (ec, er), weight, color in self._linecmds:

			if sc < 0: sc = sc + self._ncols

			if ec < 0: ec = ec + self._ncols

			if sr < 0: sr = sr + self._nrows

			if er < 0: er = er + self._nrows

			if op in ('BOX','OUTLINE','GRID'):

				if sr<n and er>=n:

					# we have to split the BOX

					A.append(('LINEABOVE',(sc,sr), (ec,sr), weight, color))

					A.append(('LINEBEFORE',(sc,sr), (sc,er), weight, color))

					A.append(('LINEAFTER',(ec,sr), (ec,er), weight, color))

					A.append(('LINEBELOW',(sc,er), (ec,er), weight, color))

					if op=='GRID':

						A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color))

						A.append(('LINEABOVE',(sc,n), (ec,n), weight, color))

						A.append(('INNERGRID',(sc,sr), (ec,er), weight, color))

				else:

					A.append((op,(sc,sr), (ec,er), weight, color))

			elif op in ('INNERGRID','LINEABOVE'):

				if sr<n and er>=n:

					A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color))

					A.append(('LINEABOVE',(sc,n), (ec,n), weight, color))

				A.append((op,(sc,sr), (ec,er), weight, color))

			elif op == 'LINEBELOW':

				if sr<n and er>=(n-1):

					A.append(('LINEABOVE',(sc,n), (ec,n), weight, color))

				A.append((op,(sc,sr), (ec,er), weight, color))

			elif op == 'LINEABOVE':

				if sr<=n and er>=n:

					A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color))

				A.append((op,(sc,sr), (ec,er), weight, color))

			else:

				A.append((op,(sc,sr), (ec,er), weight, color))

		R0._cr_0(n,A)

		R0._cr_0(n,self._bkgrndcmds)

		if repeatRows:

			R1 = Table(data[:repeatRows]+data[n:],

					self._argW, self._argH[:repeatRows]+self._argH[n:],

					repeatRows=repeatRows, repeatCols=repeatCols,

					splitByRow=splitByRow)

			R1._cellStyles = self._cellStyles[:repeatRows]+self._cellStyles[n:]

			R1._cr_1_1(n,repeatRows,A)

			R1._cr_1_1(n,repeatRows,self._bkgrndcmds)

		else:

			R1 = Table(data[n:], self._argW, self._argH[n:],

					repeatRows=repeatRows, repeatCols=repeatCols,

					splitByRow=splitByRow)

			R1._cellStyles = self._cellStyles[n:]

			R1._cr_1_0(n,A)

			R1._cr_1_0(n,self._bkgrndcmds)

		self.onSplit(R0)

		self.onSplit(R1)

		return [R0,R1]

	def split(self, availWidth, availHeight):

		self._calc()

		if self.splitByRow:

			if self._width>availWidth: return []

			return self._splitRows(availHeight)

		else:

			raise NotImplementedError

	def draw(self):

		nudge = 0.5 * (self.availWidth - self._width)

		self.canv.translate(nudge, 0)

		self._drawBkgrnd()

		self._drawLines()

		for row, rowstyle, rowpos, rowheight in map(None, self._cellvalues, self._cellStyles, self._rowpositions[1:], self._rowHeights):

			for cellval, cellstyle, colpos, colwidth in map(None, row, rowstyle, self._colpositions[:-1], self._colWidths):

				self._drawCell(cellval, cellstyle, (colpos, rowpos), (colwidth, rowheight))

	def _drawBkgrnd(self):

		for cmd, (sc, sr), (ec, er), color in self._bkgrndcmds:

			if sc < 0: sc = sc + self._ncols

			if ec < 0: ec = ec + self._ncols

			if sr < 0: sr = sr + self._nrows

			if er < 0: er = er + self._nrows

			color = colors.toColor(color)

			x0 = self._colpositions[sc]

			y0 = self._rowpositions[sr]

			x1 = self._colpositions[ec+1]

			y1 = self._rowpositions[er+1]

			self.canv.setFillColor(color)

			self.canv.rect(x0, y0, x1-x0, y1-y0,stroke=0,fill=1)

	def _drawCell(self, cellval, cellstyle, (colpos, rowpos), (colwidth, rowheight)):

		if self._curcellstyle is not cellstyle:

			cur = self._curcellstyle

			if cur is None or cellstyle.color != cur.color:

				self.canv.setFillColor(cellstyle.color)

			if cur is None or cellstyle.leading != cur.leading or cellstyle.fontname != cur.fontname or cellstyle.fontsize != cur.fontsize:

				self.canv.setFont(cellstyle.fontname, cellstyle.fontsize, cellstyle.leading)

			self._curcellstyle = cellstyle

		just = cellstyle.alignment

		valign = cellstyle.valign

		n = type(cellval)

		if n in _SeqTypes or isinstance(cellval,Flowable):

			if not n in _SeqTypes: cellval = (cellval,)

			# we assume it's a list of Flowables

			W = []

			H = []

			w, h = _listCellGeom(cellval,colwidth,cellstyle,W=W, H=H)

			if valign=='TOP':

				y = rowpos + rowheight - cellstyle.topPadding

			elif valign=='BOTTOM':

				y = rowpos+cellstyle.bottomPadding + h

			else:

				y = rowpos+(rowheight+cellstyle.bottomPadding-cellstyle.topPadding+h)/2.0

			y = y+cellval[0].getSpaceBefore()

			for v, w, h in map(None,cellval,W,H):

				if just=='LEFT': x = colpos+cellstyle.leftPadding

				elif just=='RIGHT': x = colpos+colwidth-cellstyle.rightPadding - w

				elif just in ('CENTRE', 'CENTER'):

					x = colpos+(colwidth+cellstyle.leftPadding-cellstyle.rightPadding-w)/2.0

				else:

					raise ValueError, 'Invalid justification %s' % just

				y = y - v.getSpaceBefore()

				y = y - h

				v.drawOn(self.canv,x,y)

				y = y - v.getSpaceAfter()

		else:

			if just == 'LEFT':

				draw = self.canv.drawString

				x = colpos + cellstyle.leftPadding

			elif just in ('CENTRE', 'CENTER'):

				draw = self.canv.drawCentredString

				x = colpos + colwidth * 0.5

			elif just == 'RIGHT':

				draw = self.canv.drawRightString

				x = colpos + colwidth - cellstyle.rightPadding

			else:

				raise ValueError, 'Invalid justification %s' % just

			if n is StringType: val = cellval

			else: val = str(cellval)

			vals = string.split(val, "\n")

			n = len(vals)

			leading = cellstyle.leading

			fontsize = cellstyle.fontsize

			if valign=='BOTTOM':

				y = rowpos + cellstyle.bottomPadding+n*leading-fontsize

			elif valign=='TOP':