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

"""

### HACK HACK HACK

# NUDGE SHOULD BE DISABLED FOR TABLES INSIDE TABLES

DO_NUDGE = 1

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

		}

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

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

		#print "colWidths", colWidths

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

		ncols = max(map(_rowLen,data))

		if not ncols:

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

		elif len(colWidths) != ncols:

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

		elif len(rowHeights) != nrows:

		for i in range(nrows):

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

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

		#print "W is", W

		if None in H:

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

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

				h = 0

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

					t = type(v)

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

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

						if w is None:

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

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

						dW = dW + s.leftPadding + s.rightPadding

						if dW>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:

			#print "none in w"

			W = W[:]

			self._colWidths = W

			while None in W:

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

					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

		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'

		width = 0

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

		for w in W:

			#print w, width

			width = width + w

			self._colpositions.append(width)

		#print "final width", 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):

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

		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

		#print "width, height", self._width, self._height

		return (self._width, self._height)

		#return (0, self._height) # debug

	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)