#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

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

        'href': None,

        'destination':None,

        }

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"

    href = None

    destination = None

    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, getattr(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

            for a in ('spaceBefore','spaceAfter'):

                if hasattr(parent,a):

                    setattr(self,a,getattr(parent,a))

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

def _endswith(obj,s):

    try:

        return obj.endswith(s)

    except:

        return 0

class Table(Flowable):

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

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

                hAlign=None,vAlign=None):

        self.ident = ident

        self.hAlign = hAlign or 'CENTER'

        self.vAlign = vAlign or '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

        # we need a cleanup pass to ensure data is strings - non-unicode and non-null

        self._cellvalues = self.normalizeData(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 normalizeData(self, data):

        """Takes a block of input data (list of lists etc.) and

        - coerces unicode strings to non-unicode UTF8

        - coerces nulls to ''

        """

        def normCell(stuff):

            if stuff is None:

                return ''

            elif type(stuff) == type(u''):

                return stuff.encode('utf8')

            else:

                return stuff

        outData = []

        for row in data:

            outRow = [normCell(cell) for cell in row]

            outData.append(outRow)

        from pprint import pprint as pp

        #pp(outData)

        return outData

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

        if not V: return 0,0

        aH = aH - s.topPadding - s.bottomPadding

        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)

    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:

            if hasattr(v, 'width') and type(v.width) in (IntType,FloatType): return v.width

            if hasattr(v, 'drawWidth') and type(v.drawWidth) in (IntType,FloatType): return v.drawWidth

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

                w = v.minWidth() # should be all flowables

                if type(w) in (FloatType,IntType): return w

            except AttributeError:

                pass

    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:

                                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)

                            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: