#Copyright ReportLab Europe Ltd. 2000-2004

#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/tables.py

__version__=''' $Id$ '''

__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.flowables import Flowable, Preformatted

from reportlab import rl_config

from reportlab.lib.styles import PropertySet, 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',

        }

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)

def _calc_pc(V,avail):

    '''check list V for percentage or * values

    1) absolute values go through unchanged

    2) percentages are used as weights for unconsumed space

    3) if no None values were seen '*' weights are

    set equally with unclaimed space

    otherwise * weights are assigned as None'''

    R = []

    r = R.append

    I = []

    i = I.append

    J = []

    j = J.append

    s = avail

    w = n = 0.

    for v in V:

        if type(v) is type(""):

            v = v.strip()

            if not v:

                v = None

                n += 1

            elif v.endswith('%'):

                v = float(v[:-1])

                w += v

                i(len(R))

            elif v=='*':

                j(len(R))

            else:

                v = float(v)

                s -= v

        elif v is None:

            n += 1

        else:

            s -= v

        r(v)

    s = max(0.,s)

    f = s/max(100.,w)

    for i in I:

        R[i] *= f

        s -= R[i]

    s = max(0.,s)

    m = len(J)

    if m:

        v =  n==0 and s/m or None

        for j in J:

            R[j] = v

    return R

class Table(Flowable):

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

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

        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)

        self._cellvalues = []

        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,'%s(%d,%d)' % (self.__class__.__name__,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

        self._cellvalues = data

        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

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

        c = getattr(self,'_colWidths','[unknown]')

        cv = getattr(self,'_cellvalues','[unknown]')

        import pprint, string

        cv = pprint.pformat(cv)

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

        return "%s(\n rowHeights=%s,\n colWidths=%s,\n%s\n) # end table" % (self.__class__.__name__,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 = getattr(self,'_cellvalues',None)

        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)

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

        aW = w-s.leftPadding-s.rightPadding

        aH = aH - s.topPadding - s.bottomPadding

        t = 0

        w = 0

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

        for v in V:

            vw, vh = v.wrapOn(canv,aW, aH)

            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,availWidth,W=None):

        if getattr(self,'_width_calculated_once',None): return

        #comments added by Andy to Robin's slightly terse variable names

        if not W: W = _calc_pc(self._argW,availWidth)   #widths array

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

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

            saved = None

            colSpanCells = self._spanCmds and self._colSpanCells or ()

            if W is self._argW: W = W[:]

            while None in W:

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

                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 (j, i) in colSpanCells:

                        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

                W[j] = w

        self._colWidths = W

        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

        self._width_calculated_once = 1

    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, availHeight, availWidth, H=None, W=None):

        H = self._argH

        if not W: W = _calc_pc(self._argW,availWidth)   #widths array

        hmax = lim = len(H)

        longTable = getattr(self,'_longTableOptimize',None)

        if None in H:

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

            saved = None

            #get a handy list of any cells which span rows. should be ignored for sizing

            if self._spanCmds:

                rowSpanCells = self._rowSpanCells

                colSpanCells = self._colSpanCells

                spanRanges = self._spanRanges

                colpositions = self._colpositions

            else:

                rowSpanCells = colSpanCells = ()

            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)

                if longTable:

                    hmax = i

                    height = reduce(operator.add, H[:i], 0)

                    # we can stop if we have filled up all available room

                    if height > availHeight: break

                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)

                    ji = j,i

                    if ji in rowSpanCells:

                        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

                            if ji in colSpanCells:

                                t = spanRanges[ji]

                                w = max(colpositions[t[2]+1]-colpositions[t[0]],w)

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

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

                            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

            if None not in H: hmax = lim

        height = self._height = reduce(operator.add, H[:hmax], 0)

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

        for h in H[:hmax]:

            height = height - h

            self._rowpositions.append(height)

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

        self._hmax = hmax

    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 or '*' in self._colWidths) and self._hasVariWidthElements():

            W = self._calcPreliminaryWidths(availWidth) #widths

        else:

            W = None

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

            if None in self._argH:

                self._calc_width(availWidth,W=W)

        # calculate the full table height

        self._calc_height(availHeight,availWidth,W=W)

        # calculate the full table width

        self._calc_width(availWidth,W=W)

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

        W = _calc_pc(self._argW,availWidth) #widths array

        verbose = 0

        totalDefined = 0.0

        numberUndefined = 0

        for w in W:

            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 W[colNo] is None:

                siz = 1