#$Header: /tmp/reportlab/reportlab/platypus/tables.py,v 1.60 2002/07/17 22:46:24 andy_robinson Exp $

__version__=''' $Id: tables.py,v 1.60 2002/07/17 22:46:24 andy_robinson Exp $ '''

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

        }

    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

    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

    return type(x) not in _SeqTypes and 1 or len(x)

    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._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.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 = self._nrows

        if not hasattr(self,'_ncols'):

            nc = 'unknown'

        else:

            nc = self._ncols

            cv = self._cellvalues

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

        aW = w-s.leftPadding-s.rightPadding

        t = 0

        w = 0

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

        for v in V:

            vw, vh = v.wrapOn(canv,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() 

    def _calc_width(self):

        W = self._argW

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

        saved = None

        if None in W:

            W = W[:]

            self._colWidths = W

            while None in W:

                j = W.index(None)

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

                V = map(f,self._cellvalues)

                S = map(f,self._cellStyles)

                w = 0

                i = 0

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

                    i = i + 1

                    t = type(v)

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

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

                    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=pdfmetrics.stringWidth: d(a,b,c), v))

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

                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 _calc_height(self):

        H = self._argH

        W = self._argW

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

        saved = None

        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)

                    j = j + 1

                    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

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

        if hasattr(self,'_width'): return

        # calculate the full table height

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

    def setStyle(self, tblstyle):

        if type(tblstyle) is not TableStyleType:

            tblstyle = TableStyle(tblstyle)

        for cmd in tblstyle.getCommands():

            self._addCommand(cmd)

        for k,v in tblstyle._opts.items():

            setattr(self,k,v)

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

        ecp = self._colpositions[sc:ec+2]

        rp = self._rowpositions[sr:er+1]

        if len(ecp)<=1 or len(rp)<1: return

        self._prepLine(weight, color)

        scp = ecp[0]

        ecp = ecp[-1]

        for rowpos in rp:

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

        erp = self._rowpositions[sr:er+2]

        cp  = self._colpositions[sc:ec+1]

        if len(erp)<=1 or len(cp)<1: return

        self._prepLine(weight, color)

        srp = erp[0]

        erp = erp[-1]

        for colpos in cp:

            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

        return (self._width, self._height)

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

        R0 = Table( data[:n], self._colWidths, self._argH[:n],

                repeatRows=repeatRows, repeatCols=repeatCols,

                splitByRow=splitByRow)

        #copy the styles and commands

        R0._cellStyles = self._cellStyles[:n]