#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, FloatType, IntType

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={None: None, 'butt':0,'round':1,'projecting':2,'squared':2}

LINEJOINS={None: None, 'miter':0, 'mitre':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

def _hLine(canvLine, scp, ecp, y, hBlocks, FUZZ=rl_config._FUZZ):

    '''

    Draw horizontal lines; do not draw through regions specified in hBlocks

    This also serves for vertical lines with a suitable canvLine

    '''

    if hBlocks: hBlocks = hBlocks.get(y,None)

    if not hBlocks or scp>=hBlocks[-1][1]-FUZZ or ecp<=hBlocks[0][0]+FUZZ:

        canvLine(scp,y,ecp,y)

    else:

        i = 0

        n = len(hBlocks)

        while scp<ecp-FUZZ and i<n:

            x0, x1 = hBlocks[i]

            if x1<=scp+FUZZ or x0>=ecp-FUZZ:

                i += 1

                continue

            i0 = max(scp,x0)

            i1 = min(ecp,x1)

            if i0>scp: canvLine(scp,y,i0,y)

            scp = i1

        if scp<ecp-FUZZ: canvLine(scp,y,ecp,y)

def _multiLine(scp,ecp,y,canvLine,ws,count):

    offset = 0.5*(count-1)*ws

    y += offset

    for idx in xrange(count):

        canvLine(scp, y, ecp, y)

        y -= ws

def _convert2int(value, map, low, high, name, cmd):

    '''private converter tries map(value) low<=int(value)<=high or finally an error'''

    try:

        return map[value]

    except KeyError:

        try:

            ivalue = int(value)

            if low<=ivalue<=high: return ivalue

        except:

            pass

    raise ValueError('Bad %s value %s in %s'%(name,value,str(cmd)))

class Table(Flowable):

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

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

        self.ident = ident

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

        _seqCW = type(colWidths) in _SeqTypes

        _seqRH = type(rowHeights) in _SeqTypes

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

        elif colWidths and _seqCW: 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 not _seqCW: colWidths = ncols*[colWidths]

        elif len(colWidths) != ncols:

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

        if not _seqRH: rowHeights = nrows*[rowHeights]

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

        if self.ident: return self.ident

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

        else:

            return w, t

        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(e,s)

                if ew is None: return None

                w = max(w,ew)

            return w

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

        # Even if something is fixedWidth, the attribute to check is not

        # necessarily consistent (cf. Image.drawWidth).  Therefore, we'll

        # be extra-careful and fall through to this code if necessary.

        if hasattr(v, 'minWidth'):

            try:

            except AttributeError:

                pass

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

        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',rl_config.longTableOptimize)

        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 less (thanks to Gary Poster) 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()