#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 import rl_config

from reportlab.lib.styles import PropertySet, getSampleStyleSheet, ParagraphStyle

from reportlab.lib import colors

from reportlab.lib.utils import fp_str

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

		}

# experimental replacement

class CellStyle1(PropertySet):

	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"

	def __init__(self, name, parent=None):

		self.name = name

		if parent is not None:

			parent.copy(self)

	def copy(self, result=None):

		if result is None:

			result = CellStyle1()

		for name in dir(self):

			setattr(result, name, gettattr(self, name))

		return result

CellStyle = CellStyle1

class TableStyle:

	def __init__(self, cmds=None, parent=None, **kw):

		#handle inheritance from parent first.

		commands = []

		if parent:

			# copy the parents list at construction time

			commands = commands + parent.getCommands()

			self._opts = parent._opts

		if cmds:

			commands = commands + list(cmds)

		self._cmds = commands

		self._opts={}

		self._opts.update(kw)

	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)

class Table(Flowable):

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

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

		#print "colWidths", colWidths

		self.hAlign = 'CENTER'

		self.vAlign = 'MIDDLE'

		if type(data) not in _SeqTypes:

			raise ValueError, "%s invalid data type" % self.identity()

		self._nrows = nrows = len(data)

		if nrows: self._ncols = ncols = max(map(_rowLen,data))

		elif colWidths: ncols = len(colWidths)

		else: ncols = 0

		if not emptyTableAction: emptyTableAction = rl_config.emptyTableAction

		if not (nrows and ncols):

			if emptyTableAction=='error':

				raise ValueError, "%s must have at least a row and column" % self.identity()

			elif emptyTableAction=='indicate':

				self.__class__ = Preformatted

				global _emptyTableStyle

				if '_emptyTableStyle' not in globals().keys():

					_emptyTableStyle = ParagraphStyle('_emptyTableStyle')

					_emptyTableStyle.textColor = colors.red

					_emptyTableStyle.backColor = colors.yellow

				Preformatted.__init__(self,'Table(%d,%d)' % (nrows,ncols), _emptyTableStyle)

			elif emptyTableAction=='ignore':

				self.__class__ = Spacer

				Spacer.__init__(self,0,0)

			else:

				raise ValueError, '%s bad emptyTableAction: "%s"' % (self.identity(),emptyTableAction)

			return

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

		elif len(colWidths) != ncols:

			raise ValueError, "%s data error - %d columns in data but %d in grid" % (self.identity(),ncols, len(colWidths))

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

		elif len(rowHeights) != nrows:

			raise ValueError, "%s data error - %d rows in data but %d in grid" % (self.identity(),nrows, len(rowHeights))

		for i in range(nrows):

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

				raise ValueError, "%s not enough data points in row %d!" % (self.identity(),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

		# make unique cell styles for each entry

		cellrows = []

		for i in range(nrows):

			cellcols = []

			for j in range(ncols):

				cellcols.append(CellStyle(`(i,j)`))

			cellrows.append(cellcols)

		self._cellStyles = cellrows

		self._bkgrndcmds = []

		self._linecmds = []

		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 identity(self, maxLen=30):

		'''Identify our selves as well as possible'''

		vx = None

		nr = self._nrows

		if not hasattr(self,'_ncols'):

			nc = 'unknown'

		else:

			nc = self._ncols

			cv = self._cellvalues

			b = 0

			for i in xrange(nr):

				for j in xrange(nc):

					v = cv[i][j]

					t = type(v)

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

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

						r = ''

						for vij in v:

							r = vij.identity(maxLen)

							if r and r[-4:]!='>...':

								break

						if r and r[-4:]!='>...':

							ix, jx, vx, b = i, j, r, 1

					else:

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

						ix, jx, vx = i, j, v

						b = (vx and t is StringType) and 1 or 0

						if maxLen: vx = vx[:maxLen]

					if b: break

				if b: break

		if vx:

			vx = ' with cell(%d,%d) containing\n%s' % (ix,jx,repr(vx))

		else:

			vx = '...'

		return "<%s at %d %d rows x %s cols>%s" % (self.__class__.__name__, id(self), nr, nc, vx)

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

		aW = w-s.leftPadding-s.rightPadding

		t = 0

		w = 0

		canv = getattr(self,'canv',None)

		for v in V:

			vw, vh = v.wrapOn(canv,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() 

		H = self._argH

		W = self._argW

		canv = getattr(self,'canv',None)

		saved = None

		if None in H:

			if canv: saved = canv._fontname, canv._fontsize, canv._leading

			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] # values for row i

				S = self._cellStyles[i] # styles for row i

				h = 0

				j = 0

				for v, s, w in map(None, V, S, W): # value, style, width (lengths must match)

					j = j + 1

					t = type(v)

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

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

						if w is None:

							raise ValueError, "Flowable %s in cell(%d,%d) can't have auto width in\n%s" % (v[0].identity(30),i,j,self.identity(30))

						if canv: canv._fontname, canv._fontsize, canv._leading = s.fontname, s.fontsize, s.leading or 1.2*s.fontsize

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

						if canv: canv._fontname, canv._fontsize, canv._leading = saved

						#print "leftpadding, rightpadding", s.leftPadding, s.rightPadding

						dW = dW + s.leftPadding + s.rightPadding

						if not rl_config.allowTableBoundsErrors and dW>w:

							raise "LayoutError", "Flowable %s (%sx%s points) too wide for cell(%d,%d) (%sx* points) in\n%s" % (v[0].identity(30),fp_str(dW),fp_str(t),i,j, fp_str(w), self.identity(30))

					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

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

		#print "height, H", height, H

		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'

	def setStyle(self, tblstyle):

		if type(tblstyle) is not TableStyleType:

			tblstyle = TableStyle(tblstyle)

		for cmd in tblstyle.getCommands():

			self._addCommand(cmd)

		for k,v in tblstyle._opts.items():

			setattr(self,k,v)

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

		# use round caps

		self.canv.setLineCap(1)

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

		ecp = self._colpositions[sc:ec+2]

		rp = self._rowpositions[sr:er+1]

		if len(ecp)<=1 or len(rp)<1: return

		self._prepLine(weight, color)

		scp = ecp[0]

		ecp = ecp[-1]

		for rowpos in rp:

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

		erp = self._rowpositions[sr:er+2]

		cp  = self._colpositions[sc:ec+1]

		if len(erp)<=1 or len(cp)<1: return

		self._prepLine(weight, color)

		srp = erp[0]

		erp = erp[-1]

		for colpos in cp:

			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

				repeatRows=repeatRows, repeatCols=repeatCols,

				splitByRow=splitByRow)

		#copy the styles and commands