#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

from reportlab.platypus.flowables import PageBreak

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

        }

LINECAPS={'butt':0,'round':1,'projecting':2,'squared':2}

LINEJOINS={'miter':0,'round':1,'bevel':2}

# 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._cellvalues = data

        self._rowHeights = self._argH = rowHeights

        self._colWidths = self._argW = colWidths

        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._spanCmds = []

        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 = getattr(self,'_nrows','unknown')

        nc = getattr(self,'_ncols','unknown')

        cv = self._cellvalues

        if cv and 'unknown' not in (nr,nc):

            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)

        aW = w-s.leftPadding-s.rightPadding

        t = 0

        w = 0

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

        for v in V:

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

    def _calc_width(self):

        #comments added by Andy to Robin's slightly

        #terse variable names

        W = self._argW  #widths array

        #print 'widths array = %s' % str(self._colWidths)

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

        saved = None

        if None in W:  #some column widths are not given

            if self._spanCmds:

                colspans = self._colSpannedCells

            else:

                colspans = {}

##            k = colspans.keys()

##            k.sort()

##            print 'the following cells are part of spanned ranges: %s' % k

            W = W[:]

            self._colWidths = W

            while None in W:

                j = W.index(None) #find first unspecified column

                #print 'sizing column %d' % j

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

                V = map(f,self._cellvalues)  #values for this column

                S = map(f,self._cellStyles)  #styles for this column

                w = 0

                i = 0

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

                    #if the current cell is part of a spanned region,

                    #assume a zero size.

                    if colspans.has_key((j, i)):

                        #print 'sizing a spanned cell (%d, %d) with content "%s"' % (j, i, str(v))

                        t = 0.0

                    else:#work out size

                        t = self._elementWidth(v,s)

                        if t is None:

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

                        t = t + s.leftPadding+s.rightPadding

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

                    i = i + 1

                #print 'max width for column %d is %0.2f' % (j, w)

                W[j] = w

        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 _elementWidth(self,v,s):

        t = type(v)

        if t in _SeqTypes:

            w = 0

            for e in v:

                ew = self._elementWidth(self,v)

                if ew is None: return None

                w = max(w,ew)

            return w

        elif isinstance(v,Flowable) and v._fixedWidth:

            return v.width

        else:

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

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

            return max(map(lambda a, b=s.fontname, c=s.fontsize,d=pdfmetrics.stringWidth: d(a,b,c), v))

    def _calc_height(self):

        H = self._argH

        W = self._argW

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

        saved = None

        #get a handy list of any cells which span rows.

        #these should be ignored for sizing

        if self._spanCmds:

            spans = self._rowSpannedCells

        else:

            spans = {}

        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)

                    if spans.has_key((j, i)):

                        t = 0.0  # don't count it, it's either occluded or unreliable

                    else:

                        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

                    j = j + 1

                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 _calc(self, availWidth, availHeight):

        if hasattr(self,'_width'): return

        #in some cases there are unsizable things in

        #cells.  If so, apply a different algorithm

        #and assign some withs in a dumb way.

        #this CHANGES the widths array.

        if None in self._colWidths:

            if self._hasVariWidthElements():

                self._calcPreliminaryWidths(availWidth)

        # need to know which cells are part of spanned

        # ranges, so _calc_height and _calc_width can ignore them

        # in sizing

        if self._spanCmds:

            self._calcSpanRanges()

        # calculate the full table height

        #print 'during calc, self._colWidths=', self._colWidths

        self._calc_height()

        # if the width has already been calculated, don't calculate again

        # there's surely a better, more pythonic way to short circuit this FIXME FIXME

        if hasattr(self,'_width_calculated_once'): return

        self._width_calculated_once = 1

        # calculate the full table width

        self._calc_width()

        if self._spanCmds:

            #now work out the actual rect for each spanned cell

            #from the underlying grid

            self._calcSpanRects()

    def _hasVariWidthElements(self, upToRow=None):

        """Check for flowables in table cells and warn up front.

        Allow a couple which we know are fixed size such as

        images and graphics."""

        bad = 0

        if upToRow is None: upToRow = self._nrows

        for row in range(min(self._nrows, upToRow)):

            for col in range(self._ncols):

                value = self._cellvalues[row][col]

                if not self._canGetWidth(value):

                    bad = 1

                    #raise Exception('Unsizable elements found at row %d column %d in table with content:\n %s' % (row, col, value))

        return bad

    def _canGetWidth(self, thing):

        "Can we work out the width quickly?"

        if type(thing) in (ListType, TupleType):

            for elem in thing:

                if not self._canGetWidth(elem):

                    return 0

            return 1

        elif isinstance(thing, Flowable):

            return thing._fixedWidth  # must loosen this up

        else: #string, number, None etc.

            #anything else gets passed to str(...)

            # so should be sizable

            return 1

    def _calcPreliminaryWidths(self, availWidth):

        """Fallback algorithm for when main one fails.

        Where exact width info not given but things like

        paragraphs might be present, do a preliminary scan

        and assign some sensible values - just divide up

        all unsizeable columns by the remaining space."""

        verbose = 0

        totalDefined = 0.0

        numberUndefined = 0

        for w in self._colWidths:

            if w is None:

                numberUndefined = numberUndefined + 1

            else:

                totalDefined = totalDefined + w

        if verbose: print 'prelim width calculation.  %d columns, %d undefined width, %0.2f units remain' % (

            self._ncols, numberUndefined, availWidth - totalDefined)

        #check columnwise in each None column to see if they are sizable.

        given = []

        sizeable = []

        unsizeable = []

        for colNo in range(self._ncols):

            if self._colWidths[colNo] is None:

                siz = 1

                for rowNo in range(self._nrows):

                    value = self._cellvalues[rowNo][colNo]

                    if not self._canGetWidth(value):

                        siz = 0

                        break

                if siz:

                    sizeable.append(colNo)

                else:

                    unsizeable.append(colNo)

            else:

                given.append(colNo)

        if len(given) == self._ncols:

            return

        if verbose: print 'predefined width:   ',given

        if verbose: print 'uncomputable width: ',unsizeable

        if verbose: print 'computable width:    ',sizeable

        #how much width is left:

        # on the next iteration we could size the sizeable ones, for now I'll just

        # divide up the space

        newColWidths = list(self._colWidths)

        guessColWidth = (availWidth - totalDefined) / (len(unsizeable)+len(sizeable))

        assert guessColWidth >= 0, "table is too wide already, cannot choose a sane width for undefined columns"

        if verbose: print 'assigning width %0.2f to all undefined columns' % guessColWidth

        for colNo in sizeable:

            newColWidths[colNo] = guessColWidth

        for colNo in unsizeable:

            newColWidths[colNo] = guessColWidth

        self._colWidths = newColWidths

        self._argW = newColWidths

        if verbose: print 'new widths are:', self._colWidths

    def _calcSpanRanges(self):

        """Work out rects for tables which do row and column spanning.

        This creates some mappings to let the later code determine

        if a cell is part of a "spanned" range.

        self._spanRanges shows the 'coords' in integers of each

        'cell range', or None if it was clobbered: