reportlab/platypus/tables.py
author rgbecker
Wed, 16 Mar 2005 09:47:07 +0000
changeset 2463 67935cd21f54
parent 2443 41262322cc3d
child 2464 09cfec86fa5a
permissions -rwxr-xr-x
tables.py: empty cellval patch from Jean-Francois Gosset
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2332
2a7ab4405e18 Remove $Header:, fix CopyRight & history
rgbecker
parents: 2314
diff changeset
     1
#Copyright ReportLab Europe Ltd. 2000-2004
494
54257447cfe9 Changed to indirect copyright
rgbecker
parents: 421
diff changeset
     2
#see license.txt for license details
2332
2a7ab4405e18 Remove $Header:, fix CopyRight & history
rgbecker
parents: 2314
diff changeset
     3
#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/tables.py
2a7ab4405e18 Remove $Header:, fix CopyRight & history
rgbecker
parents: 2314
diff changeset
     4
__version__=''' $Id$ '''
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
     5
16
f9c7525619fb Docstring & other fixes
rgbecker
parents: 7
diff changeset
     6
__doc__="""
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
     7
Tables are created by passing the constructor a tuple of column widths, a tuple of row heights and the data in
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
     8
row order. Drawing of the table can be controlled by using a TableStyle instance. This allows control of the
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
     9
color and weight of the lines (if any), and the font, alignment and padding of the text.
268
8414113fa500 more documentation changes
aaron_watters
parents: 253
diff changeset
    10
327
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    11
None values in the sequence of row heights or column widths, mean that the corresponding rows
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    12
or columns should be automatically sized.
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    13
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    14
All the cell values should be convertible to strings; embedded newline '\\n' characters
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    15
cause the value to wrap (ie are like a traditional linefeed).
0944cd1f3f80 Adjusted doc string
rgbecker
parents: 326
diff changeset
    16
268
8414113fa500 more documentation changes
aaron_watters
parents: 253
diff changeset
    17
See the test output from running this module as a script for a discussion of the method for constructing
8414113fa500 more documentation changes
aaron_watters
parents: 253
diff changeset
    18
tables and table styles.
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
    19
"""
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
    20
from reportlab.platypus.flowables import Flowable, Preformatted
1207
49a514d10cb0 make tables one point off not bomb mysteriously in paid production installations.
aaron_watters
parents: 1169
diff changeset
    21
from reportlab import rl_config
2384
6d44252e1042 platypus: added ptocontainer, moved tables test
rgbecker
parents: 2374
diff changeset
    22
from reportlab.lib.styles import PropertySet, ParagraphStyle
168
02bac1346c69 Tables changed to use reportlab.lib.colors instead of
andy_robinson
parents: 129
diff changeset
    23
from reportlab.lib import colors
1103
857af510186d Added identity method to Flowables
rgbecker
parents: 906
diff changeset
    24
from reportlab.lib.utils import fp_str
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
    25
from reportlab.pdfbase import pdfmetrics
312
b39b1a2ed9d5 support explicit \n line splitting in cells
aaron_watters
parents: 268
diff changeset
    26
import operator, string
421
6dd1e6e707b7 Flowable cell fixes/changes
rgbecker
parents: 420
diff changeset
    27
from types import TupleType, ListType, StringType
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
    28
128
a0676f013314 Splitting layout.py
rgbecker
parents: 122
diff changeset
    29
class CellStyle(PropertySet):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    30
    defaults = {
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    31
        'fontname':'Times-Roman',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    32
        'fontsize':10,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    33
        'leading':12,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    34
        'leftPadding':6,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    35
        'rightPadding':6,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    36
        'topPadding':3,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    37
        'bottomPadding':3,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    38
        'firstLineIndent':0,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    39
        'color':colors.black,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    40
        'alignment': 'LEFT',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    41
        'background': (1,1,1),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    42
        'valign': 'BOTTOM',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    43
        }
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
    44
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
    45
LINECAPS={'butt':0,'round':1,'projecting':2,'squared':2}
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
    46
LINEJOINS={'miter':0,'round':1,'bevel':2}
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
    47
730
48a169b27fe4 changed handling of table element styles for better space/time. old code left commented
aaron_watters
parents: 684
diff changeset
    48
# experimental replacement
48a169b27fe4 changed handling of table element styles for better space/time. old code left commented
aaron_watters
parents: 684
diff changeset
    49
class CellStyle1(PropertySet):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    50
    fontname = "Times-Roman"
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    51
    fontsize = 10
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    52
    leading = 12
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    53
    leftPadding = 6
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    54
    rightPadding = 6
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    55
    topPadding = 3
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    56
    bottomPadding = 3
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    57
    firstLineIndent = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    58
    color = colors.black
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    59
    alignment = 'LEFT'
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    60
    background = (1,1,1)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    61
    valign = "BOTTOM"
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    62
    def __init__(self, name, parent=None):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    63
        self.name = name
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    64
        if parent is not None:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    65
            parent.copy(self)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    66
    def copy(self, result=None):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    67
        if result is None:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    68
            result = CellStyle1()
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    69
        for name in dir(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    70
            setattr(result, name, gettattr(self, name))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    71
        return result
730
48a169b27fe4 changed handling of table element styles for better space/time. old code left commented
aaron_watters
parents: 684
diff changeset
    72
CellStyle = CellStyle1
48a169b27fe4 changed handling of table element styles for better space/time. old code left commented
aaron_watters
parents: 684
diff changeset
    73
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
    74
class TableStyle:
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    75
    def __init__(self, cmds=None, parent=None, **kw):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    76
        #handle inheritance from parent first.
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    77
        commands = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    78
        if parent:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    79
            # copy the parents list at construction time
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    80
            commands = commands + parent.getCommands()
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    81
            self._opts = parent._opts
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    82
        if cmds:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    83
            commands = commands + list(cmds)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    84
        self._cmds = commands
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    85
        self._opts={}
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    86
        self._opts.update(kw)
1435
4d0f57749e18 Added _opts to TableStyle for possible keepWithNext
rgbecker
parents: 1253
diff changeset
    87
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    88
    def add(self, *cmd):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    89
        self._cmds.append(cmd)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    90
    def __repr__(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    91
        L = map(repr, self._cmds)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    92
        import string
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    93
        L = string.join(L, "  \n")
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    94
        return "TableStyle(\n%s\n) # end TableStyle" % L
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    95
    def getCommands(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
    96
        return self._cmds
338
f5eb86d4224f Cosmetics and error testing
rgbecker
parents: 333
diff changeset
    97
f5eb86d4224f Cosmetics and error testing
rgbecker
parents: 333
diff changeset
    98
TableStyleType = type(TableStyle())
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
    99
_SeqTypes = (TupleType, ListType)
356
377367fe28cb Table argument order changed
rgbecker
parents: 354
diff changeset
   100
377367fe28cb Table argument order changed
rgbecker
parents: 354
diff changeset
   101
def _rowLen(x):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   102
    return type(x) not in _SeqTypes and 1 or len(x)
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
   103
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   104
def _calc_pc(V,avail):
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   105
    '''check list V for percentage or * values
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   106
    1) absolute values go through unchanged
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   107
    2) percentages are used as weights for unconsumed space
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   108
    3) if no None values were seen '*' weights are
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   109
    set equally with unclaimed space
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   110
    otherwise * weights are assigned as None'''
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   111
    R = []
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   112
    r = R.append
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   113
    I = []
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   114
    i = I.append
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   115
    J = []
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   116
    j = J.append
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   117
    s = avail
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   118
    w = n = 0.
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   119
    for v in V:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   120
        if type(v) is type(""):
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   121
            v = v.strip()
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   122
            if not v:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   123
                v = None
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   124
                n += 1
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   125
            elif v.endswith('%'):
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   126
                v = float(v[:-1])
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   127
                w += v
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   128
                i(len(R))
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   129
            elif v=='*':
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   130
                j(len(R))
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   131
            else:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   132
                v = float(v)
2284
b181b45c6792 Minor changes
rgbecker
parents: 2277
diff changeset
   133
                s -= v
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   134
        elif v is None:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   135
            n += 1
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   136
        else:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   137
            s -= v
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   138
        r(v)
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   139
    s = max(0.,s)
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   140
    f = s/max(100.,w)
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   141
    for i in I:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   142
        R[i] *= f
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   143
        s -= R[i]
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   144
    s = max(0.,s)
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   145
    m = len(J)
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   146
    if m:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   147
        v =  n==0 and s/m or None
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   148
        for j in J:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   149
            R[j] = v
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   150
    return R
356
377367fe28cb Table argument order changed
rgbecker
parents: 354
diff changeset
   151
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   152
def _hLine(canvLine, scp, ecp, y, hBlocks, FUZZ=rl_config._FUZZ):
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   153
    '''
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   154
    Draw horizontal lines; do not draw through regions specified in hBlocks
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   155
    This also serves for vertical lines with a suitable canvLine
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   156
    '''
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   157
    if hBlocks: hBlocks = hBlocks.get(y,None)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   158
    if not hBlocks or scp>=hBlocks[-1][1]-FUZZ or ecp<=hBlocks[0][0]+FUZZ:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   159
        canvLine(scp,y,ecp,y)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   160
    else:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   161
        i = 0
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   162
        n = len(hBlocks)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   163
        while scp<ecp-FUZZ and i<n:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   164
            x0, x1 = hBlocks[i]
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   165
            if x1<=scp+FUZZ or x0>=ecp-FUZZ:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   166
                i += 1
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   167
                continue
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   168
            i0 = max(scp,x0)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   169
            i1 = min(ecp,x1)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   170
            if i0>scp: canvLine(scp,y,i0,y)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   171
            scp = i1
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   172
        if scp<ecp-FUZZ: canvLine(scp,y,ecp,y)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   173
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   174
def _multiLine(scp,ecp,y,canvLine,ws,count):
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   175
    offset = 0.5*(count-1)*ws
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   176
    y += offset
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   177
    for idx in xrange(count):
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   178
        canvLine(scp, y, ecp, y)
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   179
        y -= ws
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   180
221
3d71b66b14c6 Changes related to removal of SimpleFlowDocument
rgbecker
parents: 168
diff changeset
   181
class Table(Flowable):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   182
    def __init__(self, data, colWidths=None, rowHeights=None, style=None,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   183
                repeatRows=0, repeatCols=0, splitByRow=1, emptyTableAction=None):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   184
        self.hAlign = 'CENTER'
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   185
        self.vAlign = 'MIDDLE'
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   186
        if type(data) not in _SeqTypes:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   187
            raise ValueError, "%s invalid data type" % self.identity()
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   188
        self._nrows = nrows = len(data)
2221
cd3b787b38a9 corrected erroneous comment
andy_robinson
parents: 2220
diff changeset
   189
        self._cellvalues = []
2401
cd68d7a84d05 CanvasAdapter related changes
rgbecker
parents: 2397
diff changeset
   190
        _seqCW = type(colWidths) in _SeqTypes
cd68d7a84d05 CanvasAdapter related changes
rgbecker
parents: 2397
diff changeset
   191
        _seqRH = type(rowHeights) in _SeqTypes
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   192
        if nrows: self._ncols = ncols = max(map(_rowLen,data))
2401
cd68d7a84d05 CanvasAdapter related changes
rgbecker
parents: 2397
diff changeset
   193
        elif colWidths and _seqCW: ncols = len(colWidths)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   194
        else: ncols = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   195
        if not emptyTableAction: emptyTableAction = rl_config.emptyTableAction
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   196
        if not (nrows and ncols):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   197
            if emptyTableAction=='error':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   198
                raise ValueError, "%s must have at least a row and column" % self.identity()
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   199
            elif emptyTableAction=='indicate':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   200
                self.__class__ = Preformatted
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   201
                global _emptyTableStyle
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   202
                if '_emptyTableStyle' not in globals().keys():
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   203
                    _emptyTableStyle = ParagraphStyle('_emptyTableStyle')
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   204
                    _emptyTableStyle.textColor = colors.red
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   205
                    _emptyTableStyle.backColor = colors.yellow
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   206
                Preformatted.__init__(self,'%s(%d,%d)' % (self.__class__.__name__,nrows,ncols), _emptyTableStyle)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   207
            elif emptyTableAction=='ignore':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   208
                self.__class__ = Spacer
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   209
                Spacer.__init__(self,0,0)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   210
            else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   211
                raise ValueError, '%s bad emptyTableAction: "%s"' % (self.identity(),emptyTableAction)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   212
            return
1533
e25c4dda4840 Added emptyTableAction
rgbecker
parents: 1499
diff changeset
   213
2299
d757841f2006 Fix proposed by Derik Barclay <dbarclay@givex.com>
rgbecker
parents: 2289
diff changeset
   214
        self._cellvalues = data
2401
cd68d7a84d05 CanvasAdapter related changes
rgbecker
parents: 2397
diff changeset
   215
        if not _seqCW: colWidths = ncols*[colWidths]
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   216
        elif len(colWidths) != ncols:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   217
            raise ValueError, "%s data error - %d columns in data but %d in grid" % (self.identity(),ncols, len(colWidths))
2401
cd68d7a84d05 CanvasAdapter related changes
rgbecker
parents: 2397
diff changeset
   218
        if not _seqRH: rowHeights = nrows*[rowHeights]
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   219
        elif len(rowHeights) != nrows:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   220
            raise ValueError, "%s data error - %d rows in data but %d in grid" % (self.identity(),nrows, len(rowHeights))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   221
        for i in range(nrows):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   222
            if len(data[i]) != ncols:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   223
                raise ValueError, "%s not enough data points in row %d!" % (self.identity(),i)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   224
        self._rowHeights = self._argH = rowHeights
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   225
        self._colWidths = self._argW = colWidths
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   226
        cellrows = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   227
        for i in range(nrows):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   228
            cellcols = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   229
            for j in range(ncols):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   230
                cellcols.append(CellStyle(`(i,j)`))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   231
            cellrows.append(cellcols)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   232
        self._cellStyles = cellrows
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   233
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   234
        self._bkgrndcmds = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   235
        self._linecmds = []
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   236
        self._spanCmds = []
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   237
        self.repeatRows = repeatRows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   238
        self.repeatCols = repeatCols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   239
        self.splitByRow = splitByRow
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
   240
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   241
        if style:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   242
            self.setStyle(style)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   243
    def __repr__(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   244
        "incomplete, but better than nothing"
2389
174fe506bf48 tables.py: robustify repr
rgbecker
parents: 2384
diff changeset
   245
        r = getattr(self,'_rowHeights','[unknown]')
174fe506bf48 tables.py: robustify repr
rgbecker
parents: 2384
diff changeset
   246
        c = getattr(self,'_colWidths','[unknown]')
174fe506bf48 tables.py: robustify repr
rgbecker
parents: 2384
diff changeset
   247
        cv = getattr(self,'_cellvalues','[unknown]')
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   248
        import pprint, string
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   249
        cv = pprint.pformat(cv)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   250
        cv = string.replace(cv, "\n", "\n  ")
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   251
        return "%s(\n rowHeights=%s,\n colWidths=%s,\n%s\n) # end table" % (self.__class__.__name__,r,c,cv)
342
a6982189331d Added tables to PythonPoint
andy_robinson
parents: 338
diff changeset
   252
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   253
    def identity(self, maxLen=30):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   254
        '''Identify our selves as well as possible'''
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   255
        vx = None
1989
a91ec8282d6e Attempt to fix up identity for early errors
rgbecker
parents: 1917
diff changeset
   256
        nr = getattr(self,'_nrows','unknown')
a91ec8282d6e Attempt to fix up identity for early errors
rgbecker
parents: 1917
diff changeset
   257
        nc = getattr(self,'_ncols','unknown')
2299
d757841f2006 Fix proposed by Derik Barclay <dbarclay@givex.com>
rgbecker
parents: 2289
diff changeset
   258
        cv = getattr(self,'_cellvalues',None)
1989
a91ec8282d6e Attempt to fix up identity for early errors
rgbecker
parents: 1917
diff changeset
   259
        if cv and 'unknown' not in (nr,nc):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   260
            b = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   261
            for i in xrange(nr):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   262
                for j in xrange(nc):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   263
                    v = cv[i][j]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   264
                    t = type(v)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   265
                    if t in _SeqTypes or isinstance(v,Flowable):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   266
                        if not t in _SeqTypes: v = (v,)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   267
                        r = ''
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   268
                        for vij in v:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   269
                            r = vij.identity(maxLen)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   270
                            if r and r[-4:]!='>...':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   271
                                break
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   272
                        if r and r[-4:]!='>...':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   273
                            ix, jx, vx, b = i, j, r, 1
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   274
                    else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   275
                        v = v is None and '' or str(v)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   276
                        ix, jx, vx = i, j, v
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   277
                        b = (vx and t is StringType) and 1 or 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   278
                        if maxLen: vx = vx[:maxLen]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   279
                    if b: break
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   280
                if b: break
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   281
        if vx:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   282
            vx = ' with cell(%d,%d) containing\n%s' % (ix,jx,repr(vx))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   283
        else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   284
            vx = '...'
1103
857af510186d Added identity method to Flowables
rgbecker
parents: 906
diff changeset
   285
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   286
        return "<%s at %d %d rows x %s cols>%s" % (self.__class__.__name__, id(self), nr, nc, vx)
1103
857af510186d Added identity method to Flowables
rgbecker
parents: 906
diff changeset
   287
2189
47cb423f5f1a Make _listCellGeom more specific
rgbecker
parents: 2185
diff changeset
   288
    def _listCellGeom(self, V,w,s,W=None,H=None,aH=72000):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   289
        aW = w-s.leftPadding-s.rightPadding
2189
47cb423f5f1a Make _listCellGeom more specific
rgbecker
parents: 2185
diff changeset
   290
        aH = aH - s.topPadding - s.bottomPadding
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   291
        t = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   292
        w = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   293
        canv = getattr(self,'canv',None)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   294
        for v in V:
2189
47cb423f5f1a Make _listCellGeom more specific
rgbecker
parents: 2185
diff changeset
   295
            vw, vh = v.wrapOn(canv,aW, aH)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   296
            if W is not None: W.append(vw)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   297
            if H is not None: H.append(vh)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   298
            w = max(w,vw)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   299
            t = t + vh + v.getSpaceBefore()+v.getSpaceAfter()
2463
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
   300
        else:
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
   301
            return w, t
1683
7fa753e4420a Removed all trailing whitespace
andy_robinson
parents: 1677
diff changeset
   302
        return w, t - V[0].getSpaceBefore()-V[-1].getSpaceAfter()
1492
612646d068ca Ensure canv is set on sub flowables
rgbecker
parents: 1488
diff changeset
   303
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   304
    def _calc_width(self,availWidth,W=None):
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   305
        if getattr(self,'_width_calculated_once',None): return
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   306
        #comments added by Andy to Robin's slightly terse variable names
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   307
        if not W: W = _calc_pc(self._argW,availWidth)   #widths array
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   308
        if None in W:  #some column widths are not given
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   309
            canv = getattr(self,'canv',None)
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   310
            saved = None
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   311
            colSpanCells = self._spanCmds and self._colSpanCells or ()
2277
1473cfff7a24 Ensure _colWidths is defined
rgbecker
parents: 2271
diff changeset
   312
            if W is self._argW: W = W[:]
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   313
            while None in W:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   314
                j = W.index(None) #find first unspecified column
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   315
                f = lambda x,j=j: operator.getitem(x,j)
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   316
                V = map(f,self._cellvalues)  #values for this column
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   317
                S = map(f,self._cellStyles)  #styles for this column
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   318
                w = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   319
                i = 0
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   320
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   321
                for v, s in map(None, V, S):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   322
                    #if the current cell is part of a spanned region,
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   323
                    #assume a zero size.
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   324
                    if (j, i) in colSpanCells:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   325
                        t = 0.0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   326
                    else:#work out size
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   327
                        t = self._elementWidth(v,s)
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   328
                        if t is None:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   329
                            raise ValueError, "Flowable %s in cell(%d,%d) can't have auto width\n%s" % (v.identity(30),i,j,self.identity(30))
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   330
                        t = t + s.leftPadding+s.rightPadding
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   331
                    if t>w: w = t   #record a new maximum
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   332
                    i = i + 1
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   333
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   334
                W[j] = w
1596
753865895a6f Jim Kraai's patch to preserve auto col width on subsequent pages
andy_robinson
parents: 1536
diff changeset
   335
2277
1473cfff7a24 Ensure _colWidths is defined
rgbecker
parents: 2271
diff changeset
   336
        self._colWidths = W
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   337
        width = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   338
        self._colpositions = [0]        #index -1 is right side boundary; we skip when processing cells
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   339
        for w in W:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   340
            width = width + w
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   341
            self._colpositions.append(width)
1683
7fa753e4420a Removed all trailing whitespace
andy_robinson
parents: 1677
diff changeset
   342
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   343
        self._width = width
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   344
        self._width_calculated_once = 1
1596
753865895a6f Jim Kraai's patch to preserve auto col width on subsequent pages
andy_robinson
parents: 1536
diff changeset
   345
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   346
    def _elementWidth(self,v,s):
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   347
        t = type(v)
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   348
        if t in _SeqTypes:
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   349
            w = 0
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   350
            for e in v:
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   351
                ew = self._elementWidth(self,v)
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   352
                if ew is None: return None
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   353
                w = max(w,ew)
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   354
            return w
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   355
        elif isinstance(v,Flowable) and v._fixedWidth:
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   356
            return v.width
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   357
        else:
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   358
            if t is not StringType: v = v is None and '' or str(v)
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   359
            v = string.split(v, "\n")
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   360
            return max(map(lambda a, b=s.fontname, c=s.fontsize,d=pdfmetrics.stringWidth: d(a,b,c), v))
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   361
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   362
    def _calc_height(self, availHeight, availWidth, H=None, W=None):
333
a9e94b0832a4 Fix auto hieght stuff
rgbecker
parents: 329
diff changeset
   363
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   364
        H = self._argH
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   365
        if not W: W = _calc_pc(self._argW,availWidth)   #widths array
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
   366
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   367
        hmax = lim = len(H)
2436
76dc9d73afa9 added longTableOptimize config variable
rgbecker
parents: 2414
diff changeset
   368
        longTable = getattr(self,'_longTableOptimize',rl_config.longTableOptimize)
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   369
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   370
        if None in H:
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   371
            canv = getattr(self,'canv',None)
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   372
            saved = None
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   373
            #get a handy list of any cells which span rows. should be ignored for sizing
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   374
            if self._spanCmds:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   375
                rowSpanCells = self._rowSpanCells
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   376
                colSpanCells = self._colSpanCells
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   377
                spanRanges = self._spanRanges
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   378
                colpositions = self._colpositions
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   379
            else:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   380
                rowSpanCells = colSpanCells = ()
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   381
            if canv: saved = canv._fontname, canv._fontsize, canv._leading
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   382
            H = H[:]    #make a copy as we'll change it
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   383
            self._rowHeights = H
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   384
            while None in H:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   385
                i = H.index(None)
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   386
                if longTable:
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   387
                    hmax = i
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   388
                    height = reduce(operator.add, H[:i], 0)
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   389
                    # we can stop if we have filled up all available room
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   390
                    if height > availHeight: break
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   391
                V = self._cellvalues[i] # values for row i
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   392
                S = self._cellStyles[i] # styles for row i
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   393
                h = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   394
                j = 0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   395
                for v, s, w in map(None, V, S, W): # value, style, width (lengths must match)
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   396
                    ji = j,i
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   397
                    if ji in rowSpanCells:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   398
                        t = 0.0  # don't count it, it's either occluded or unreliable
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   399
                    else:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   400
                        t = type(v)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   401
                        if t in _SeqTypes or isinstance(v,Flowable):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   402
                            if not t in _SeqTypes: v = (v,)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   403
                            if w is None:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   404
                                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))
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   405
                            if canv: canv._fontname, canv._fontsize, canv._leading = s.fontname, s.fontsize, s.leading or 1.2*s.fontsize
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   406
                            if ji in colSpanCells:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   407
                                t = spanRanges[ji]
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   408
                                w = max(colpositions[t[2]+1]-colpositions[t[0]],w)
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   409
                            dW,t = self._listCellGeom(v,w,s)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   410
                            if canv: canv._fontname, canv._fontsize, canv._leading = saved
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   411
                            dW = dW + s.leftPadding + s.rightPadding
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   412
                            if not rl_config.allowTableBoundsErrors and dW>w:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   413
                                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))
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   414
                        else:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   415
                            if t is not StringType:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   416
                                v = v is None and '' or str(v)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   417
                            v = string.split(v, "\n")
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   418
                            t = s.leading*len(v)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   419
                        t = t+s.bottomPadding+s.topPadding
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   420
                    if t>h: h = t   #record a new maximum
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   421
                    j = j + 1
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   422
                H[i] = h
2200
be0cfccc662a Fixed up tabs and whitespace in all source files
andy_robinson
parents: 2194
diff changeset
   423
            if None not in H: hmax = lim
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   424
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   425
        height = self._height = reduce(operator.add, H[:hmax], 0)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   426
        self._rowpositions = [height]    # index 0 is actually topline; we skip when processing cells
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   427
        for h in H[:hmax]:
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   428
            height = height - h
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   429
            self._rowpositions.append(height)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   430
        assert abs(height)<1e-8, 'Internal height error'
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   431
        self._hmax = hmax
1596
753865895a6f Jim Kraai's patch to preserve auto col width on subsequent pages
andy_robinson
parents: 1536
diff changeset
   432
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   433
    def _calc(self, availWidth, availHeight):
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   434
        #if hasattr(self,'_width'): return
1596
753865895a6f Jim Kraai's patch to preserve auto col width on subsequent pages
andy_robinson
parents: 1536
diff changeset
   435
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   436
        #in some cases there are unsizable things in
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   437
        #cells.  If so, apply a different algorithm
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   438
        #and assign some withs in a dumb way.
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   439
        #this CHANGES the widths array.
2284
b181b45c6792 Minor changes
rgbecker
parents: 2277
diff changeset
   440
        if (None in self._colWidths or '*' in self._colWidths) and self._hasVariWidthElements():
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   441
            W = self._calcPreliminaryWidths(availWidth) #widths
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   442
        else:
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   443
            W = None
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   444
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   445
        # need to know which cells are part of spanned
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   446
        # ranges, so _calc_height and _calc_width can ignore them
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   447
        # in sizing
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   448
        if self._spanCmds:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   449
            self._calcSpanRanges()
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   450
            if None in self._argH:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   451
                self._calc_width(availWidth,W=W)
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   452
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   453
        # calculate the full table height
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   454
        self._calc_height(availHeight,availWidth,W=W)
1596
753865895a6f Jim Kraai's patch to preserve auto col width on subsequent pages
andy_robinson
parents: 1536
diff changeset
   455
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   456
        # calculate the full table width
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   457
        self._calc_width(availWidth,W=W)
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   458
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   459
        if self._spanCmds:
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   460
            #now work out the actual rect for each spanned cell from the underlying grid
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   461
            self._calcSpanRects()
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   462
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   463
    def _hasVariWidthElements(self, upToRow=None):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   464
        """Check for flowables in table cells and warn up front.
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   465
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   466
        Allow a couple which we know are fixed size such as
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   467
        images and graphics."""
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   468
        bad = 0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   469
        if upToRow is None: upToRow = self._nrows
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   470
        for row in range(min(self._nrows, upToRow)):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   471
            for col in range(self._ncols):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   472
                value = self._cellvalues[row][col]
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   473
                if not self._canGetWidth(value):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   474
                    bad = 1
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   475
                    #raise Exception('Unsizable elements found at row %d column %d in table with content:\n %s' % (row, col, value))
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   476
        return bad
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   477
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   478
    def _canGetWidth(self, thing):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   479
        "Can we work out the width quickly?"
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   480
        if type(thing) in (ListType, TupleType):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   481
            for elem in thing:
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   482
                if not self._canGetWidth(elem):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   483
                    return 0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   484
            return 1
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   485
        elif isinstance(thing, Flowable):
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   486
            return thing._fixedWidth  # must loosen this up
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   487
        else: #string, number, None etc.
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   488
            #anything else gets passed to str(...)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   489
            # so should be sizable
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   490
            return 1
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   491
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   492
    def _calcPreliminaryWidths(self, availWidth):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   493
        """Fallback algorithm for when main one fails.
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   494
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   495
        Where exact width info not given but things like
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   496
        paragraphs might be present, do a preliminary scan
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   497
        and assign some sensible values - just divide up
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   498
        all unsizeable columns by the remaining space."""
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   499
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   500
        W = _calc_pc(self._argW,availWidth) #widths array
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   501
        verbose = 0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   502
        totalDefined = 0.0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   503
        numberUndefined = 0
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   504
        for w in W:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   505
            if w is None:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   506
                numberUndefined = numberUndefined + 1
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   507
            else:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   508
                totalDefined = totalDefined + w
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   509
        if verbose: print 'prelim width calculation.  %d columns, %d undefined width, %0.2f units remain' % (
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   510
            self._ncols, numberUndefined, availWidth - totalDefined)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   511
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   512
        #check columnwise in each None column to see if they are sizable.
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   513
        given = []
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   514
        sizeable = []
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   515
        unsizeable = []
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   516
        for colNo in range(self._ncols):
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   517
            if W[colNo] is None:
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   518
                siz = 1
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   519
                for rowNo in range(self._nrows):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   520
                    value = self._cellvalues[rowNo][colNo]
1917
25b37daf5ab7 Prepare for a more general idea of cell size
rgbecker
parents: 1912
diff changeset
   521
                    if not self._canGetWidth(value):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   522
                        siz = 0
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   523
                        break
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   524
                if siz:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   525
                    sizeable.append(colNo)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   526
                else:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   527
                    unsizeable.append(colNo)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   528
            else:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   529
                given.append(colNo)
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   530
        if len(given) == self._ncols:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   531
            return
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   532
        if verbose: print 'predefined width:   ',given
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   533
        if verbose: print 'uncomputable width: ',unsizeable
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   534
        if verbose: print 'computable width:    ',sizeable
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   535
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   536
        #how much width is left:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   537
        # on the next iteration we could size the sizeable ones, for now I'll just
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   538
        # divide up the space
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   539
        newColWidths = list(W)
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   540
        guessColWidth = (availWidth - totalDefined) / (len(unsizeable)+len(sizeable))
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   541
        assert guessColWidth >= 0, "table is too wide already, cannot choose a sane width for undefined columns"
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   542
        if verbose: print 'assigning width %0.2f to all undefined columns' % guessColWidth
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   543
        for colNo in sizeable:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   544
            newColWidths[colNo] = guessColWidth
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   545
        for colNo in unsizeable:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   546
            newColWidths[colNo] = guessColWidth
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   547
2271
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   548
        if verbose: print 'new widths are:', newColWidths
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   549
        self._argW = self._colWidths = newColWidths
602b23129c5d Added percentages
rgbecker
parents: 2221
diff changeset
   550
        return newColWidths
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   551
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   552
    def _calcSpanRanges(self):
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   553
        """Work out rects for tables which do row and column spanning.
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   554
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   555
        This creates some mappings to let the later code determine
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   556
        if a cell is part of a "spanned" range.
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   557
        self._spanRanges shows the 'coords' in integers of each
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   558
        'cell range', or None if it was clobbered:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   559
          (col, row) -> (col0, row0, col1, row1)
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   560
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   561
        Any cell not in the key is not part of a spanned region
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   562
        """
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   563
        self._spanRanges = spanRanges = {}
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   564
        for x in xrange(self._ncols):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   565
            for y in xrange(self._nrows):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   566
                spanRanges[x,y] = (x, y, x, y)
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   567
        self._colSpanCells = []
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   568
        self._rowSpanCells = []
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   569
        csa = self._colSpanCells.append
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   570
        rsa = self._rowSpanCells.append
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   571
        for (cmd, start, stop) in self._spanCmds:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   572
            x0, y0 = start
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   573
            x1, y1 = stop
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   574
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   575
            #normalize
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   576
            if x0 < 0: x0 = x0 + self._ncols
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   577
            if x1 < 0: x1 = x1 + self._ncols
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   578
            if y0 < 0: y0 = y0 + self._nrows
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   579
            if y1 < 0: y1 = y1 + self._nrows
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   580
            if x0 > x1: x0, x1 = x1, x0
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   581
            if y0 > y1: y0, y1 = y1, y0
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   582
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   583
            if x0!=x1 or y0!=y1:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   584
                #column span
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   585
                if x0!=x1:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   586
                    for y in xrange(y0, y1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   587
                        for x in xrange(x0,x1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   588
                            csa((x,y))
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   589
                #row span
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   590
                if y0!=y1:
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   591
                    for y in xrange(y0, y1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   592
                        for x in xrange(x0,x1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   593
                            rsa((x,y))
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   594
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   595
                for y in xrange(y0, y1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   596
                    for x in xrange(x0,x1+1):
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   597
                        spanRanges[x,y] = None
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   598
                # set the main entry
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   599
                spanRanges[x0,y0] = (x0, y0, x1, y1)
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   600
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   601
    def _calcSpanRects(self):
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   602
        """Work out rects for tables which do row and column spanning.
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   603
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   604
        Based on self._spanRanges, which is already known,
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   605
        and the widths which were given or previously calculated,
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   606
        self._spanRects shows the real coords for drawing:
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   607
          (col, row) -> (x, y, width, height)
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   608
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   609
        for each cell.  Any cell which 'does not exist' as another
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   610
        has spanned over it will get a None entry on the right
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   611
        """
2289
fc3840f8294d Attempt to fix the Mike Spanning example
rgbecker
parents: 2288
diff changeset
   612
        if getattr(self,'_spanRects',None): return
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   613
        colpositions = self._colpositions
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   614
        rowpositions = self._rowpositions
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   615
        self._spanRects = spanRects = {}
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   616
        self._vBlocks = vBlocks = {}
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   617
        self._hBlocks = hBlocks = {}
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   618
        for (coord, value) in self._spanRanges.items():
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   619
            if value is None:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   620
                spanRects[coord] = None
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   621
            else:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   622
                col,row = coord
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   623
                col0, row0, col1, row1 = value
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   624
                if col1-col0>0:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   625
                    for _ in xrange(col0+1,col1+1):
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   626
                        vBlocks.setdefault(colpositions[_],[]).append((rowpositions[row1+1],rowpositions[row0]))
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   627
                if row1-row0>0:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   628
                    for _ in xrange(row0+1,row1+1):
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   629
                        hBlocks.setdefault(rowpositions[_],[]).append((colpositions[col0],colpositions[col1+1]))
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   630
                x = colpositions[col0]
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   631
                y = rowpositions[row1+1]
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   632
                width = colpositions[col1+1] - x
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   633
                height = rowpositions[row0] - y
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   634
                spanRects[coord] = (x, y, width, height)
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   635
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   636
        for _ in hBlocks, vBlocks:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   637
            for value in _.values():
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   638
                value.sort()
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
   639
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   640
    def setStyle(self, tblstyle):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   641
        if type(tblstyle) is not TableStyleType:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   642
            tblstyle = TableStyle(tblstyle)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   643
        for cmd in tblstyle.getCommands():
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   644
            self._addCommand(cmd)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   645
        for k,v in tblstyle._opts.items():
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   646
            setattr(self,k,v)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   647
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   648
    def _addCommand(self,cmd):
2393
6b3e47730acc tables.py: fix buglet in command adding
rgbecker
parents: 2392
diff changeset
   649
        if cmd[0] in ('BACKGROUND','ROWBACKGROUNDS','COLBACKGROUNDS'):
2392
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
   650
            self._bkgrndcmds.append(cmd)
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   651
        elif cmd[0] == 'SPAN':
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   652
            self._spanCmds.append(cmd)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   653
        elif _isLineCommand(cmd):
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   654
            # we expect op, start, stop, weight, colour, cap, dashes, join
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   655
            cmd = tuple(cmd)
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   656
            if len(cmd)<5: raise ValueError('bad line command '+str(cmd))
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   657
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   658
            #determine line cap value at position 5. This can be string or numeric.
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   659
            if len(cmd)<6:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   660
                cmd = cmd+(1,)
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   661
            else:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   662
                cap = cmd[5]
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   663
                try:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   664
                    if type(cap) is not type(int):
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   665
                        cap = LINECAPS[cap]
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   666
                    elif cap<0 or cap>2:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   667
                        raise ValueError
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   668
                    cmd = cmd[:5]+(cap,)+cmd[6:]
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   669
                except:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   670
                    ValueError('Bad cap value %s in %s'%(cap,str(cmd)))
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   671
            #dashes at index 6 - this is a dash array:
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   672
            if len(cmd)<7: cmd = cmd+(None,)
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   673
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   674
            #join mode at index 7 - can be string or numeric, look up as for caps
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   675
            if len(cmd)<8: cmd = cmd+(1,)
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   676
            else:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   677
                join = cmd[7]
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   678
                try:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   679
                    if type(join) is not type(int):
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   680
                        join = LINEJOINS[cap]
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   681
                    elif join<0 or join>2:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   682
                        raise ValueError
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   683
                    cmd = cmd[:7]+(join,)
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   684
                except:
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   685
                    ValueError('Bad join value %s in %s'%(join,str(cmd)))
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   686
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   687
            #linecount at index 8.  Default is 1, set to 2 for double line.
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   688
            if len(cmd)<9:
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   689
                lineCount = 1
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   690
                cmd = cmd + (lineCount,)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   691
            else:
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   692
                lineCount = cmd[8]
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   693
            assert lineCount >= 1
2221
cd3b787b38a9 corrected erroneous comment
andy_robinson
parents: 2220
diff changeset
   694
            #linespacing at index 9. Not applicable unless 2+ lines, defaults to line
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   695
            #width so you get a visible gap between centres
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   696
            if len(cmd)<10: cmd = cmd + (cmd[3],)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   697
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   698
            assert len(cmd) == 10
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   699
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   700
            self._linecmds.append(cmd)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   701
        else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   702
            (op, (sc, sr), (ec, er)), values = cmd[:3] , cmd[3:]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   703
            if sc < 0: sc = sc + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   704
            if ec < 0: ec = ec + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   705
            if sr < 0: sr = sr + self._nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   706
            if er < 0: er = er + self._nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   707
            for i in range(sr, er+1):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   708
                for j in range(sc, ec+1):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   709
                    _setCellStyle(self._cellStyles, i, j, op, values)
326
159576a5816e First try at auto sizing
rgbecker
parents: 312
diff changeset
   710
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   711
    def _drawLines(self):
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   712
        ccap, cdash, cjoin = None, None, None
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   713
        self.canv.saveState()
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   714
        for op, (sc,sr), (ec,er), weight, color, cap, dash, join, count, space in self._linecmds:
2185
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   715
            if type(sr) is type('') and sr.startswith('split'): continue
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   716
            if sc < 0: sc = sc + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   717
            if ec < 0: ec = ec + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   718
            if sr < 0: sr = sr + self._nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   719
            if er < 0: er = er + self._nrows
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   720
            if cap!=None and ccap!=cap:
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   721
                self.canv.setLineCap(cap)
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   722
                ccap = cap
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   723
            getattr(self,_LineOpMap.get(op, '_drawUnknown' ))( (sc, sr), (ec, er), weight, color, count, space)
1699
37fa8717925f Improved line styles, allow for cap etc
rgbecker
parents: 1683
diff changeset
   724
        self.canv.restoreState()
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   725
        self._curcolor = None
248
c103b7a55e79 Color fixes; thanks to J Alet
rgbecker
parents: 221
diff changeset
   726
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   727
    def _drawUnknown(self,  (sc, sr), (ec, er), weight, color, count, space):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   728
        raise ValueError, "Unknown line command '%s'" % op
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
   729
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   730
    def _drawGrid(self, (sc, sr), (ec, er), weight, color, count, space):
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   731
        self._drawBox( (sc, sr), (ec, er), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   732
        self._drawInnerGrid( (sc, sr), (ec, er), weight, color, count, space)
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
   733
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   734
    def _drawBox(self,  (sc, sr), (ec, er), weight, color, count, space):
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   735
        self._drawHLines((sc, sr), (ec, sr), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   736
        self._drawHLines((sc, er+1), (ec, er+1), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   737
        self._drawVLines((sc, sr), (sc, er), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   738
        self._drawVLines((ec+1, sr), (ec+1, er), weight, color, count, space)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   739
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   740
    def _drawInnerGrid(self, (sc, sr), (ec, er), weight, color, count, space):
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   741
        self._drawHLines((sc, sr+1), (ec, er), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   742
        self._drawVLines((sc+1, sr), (ec, er), weight, color, count, space)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   743
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   744
    def _prepLine(self, weight, color):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   745
        if color != self._curcolor:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   746
            self.canv.setStrokeColor(color)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   747
            self._curcolor = color
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   748
        if weight != self._curweight:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   749
            self.canv.setLineWidth(weight)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   750
            self._curweight = weight
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   751
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   752
    def _drawHLines(self, (sc, sr), (ec, er), weight, color, count, space):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   753
        ecp = self._colpositions[sc:ec+2]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   754
        rp = self._rowpositions[sr:er+1]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   755
        if len(ecp)<=1 or len(rp)<1: return
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   756
        self._prepLine(weight, color)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   757
        scp = ecp[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   758
        ecp = ecp[-1]
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   759
        hBlocks = getattr(self,'_hBlocks',{})
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   760
        canvLine = self.canv.line
2220
7a77486a7ea7 Slightly more efficient linedrawing
rgbecker
parents: 2219
diff changeset
   761
        if count == 1:
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   762
            for y in rp:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   763
                _hLine(canvLine, scp, ecp, y, hBlocks)
2220
7a77486a7ea7 Slightly more efficient linedrawing
rgbecker
parents: 2219
diff changeset
   764
        else:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   765
            lf = lambda x0,y0,x1,y1,canvLine=canvLine, ws=weight+space, count=count: _multiLine(x0,x1,y0,canvLine,ws,count)
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   766
            for y in rp:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   767
                _hLine(lf, scp, ecp, y, hBlocks)
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
   768
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   769
    def _drawHLinesB(self, (sc, sr), (ec, er), weight, color, count, space):
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   770
        self._drawHLines((sc, sr+1), (ec, er+1), weight, color, count, space)
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   771
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   772
    def _drawVLines(self, (sc, sr), (ec, er), weight, color, count, space):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   773
        erp = self._rowpositions[sr:er+2]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   774
        cp  = self._colpositions[sc:ec+1]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   775
        if len(erp)<=1 or len(cp)<1: return
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   776
        self._prepLine(weight, color)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   777
        srp = erp[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   778
        erp = erp[-1]
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   779
        vBlocks = getattr(self,'_vBlocks',{})
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   780
        canvLine = lambda y0, x0, y1, x1, _line=self.canv.line: _line(x0,y0,x1,y1)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   781
        if count == 1:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   782
            for x in cp:
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   783
                _hLine(canvLine, erp, srp, x, vBlocks)
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   784
        else:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   785
            lf = lambda x0,y0,x1,y1,canvLine=canvLine, ws=weight+space, count=count: _multiLine(x0,x1,y0,canvLine,ws,count)
2412
b8bf2e639769 reportlab: table improvments and better documentation
rgbecker
parents: 2401
diff changeset
   786
            for x in cp:
2414
81be267fa92c tables.py: extend span line blocking to multi lines
rgbecker
parents: 2412
diff changeset
   787
                _hLine(lf, erp, srp, x, vBlocks)
326
159576a5816e First try at auto sizing
rgbecker
parents: 312
diff changeset
   788
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   789
    def _drawVLinesA(self, (sc, sr), (ec, er), weight, color, count, space):
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   790
        self._drawVLines((sc+1, sr), (ec+1, er), weight, color, count, space)
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
   791
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   792
    def wrap(self, availWidth, availHeight):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   793
        self._calc(availWidth, availHeight)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   794
        #nice and easy, since they are predetermined size
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   795
        self.availWidth = availWidth
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   796
        return (self._width, self._height)
1495
fd32c1794998 Propagate font properties to Flowable cells
rgbecker
parents: 1492
diff changeset
   797
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   798
    def onSplit(self,T,byRow=1):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   799
        '''
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   800
        This method will be called when the Table is split.
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   801
        Special purpose tables can override to do special stuff.
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   802
        '''
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   803
        pass
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
   804
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   805
    def _cr_0(self,n,cmds):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   806
        for c in cmds:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   807
            c = tuple(c)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   808
            (sc,sr), (ec,er) = c[1:3]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   809
            if sr>=n: continue
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   810
            if er>=n: er = n-1
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   811
            self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   812
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   813
    def _cr_1_1(self,n,repeatRows, cmds):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   814
        for c in cmds:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   815
            c = tuple(c)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   816
            (sc,sr), (ec,er) = c[1:3]
2185
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   817
            if sr in ('splitfirst','splitlast'): self._addCommand(c)
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   818
            else:
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   819
                if sr>=0 and sr>=repeatRows and sr<n and er>=0 and er<n: continue
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   820
                if sr>=repeatRows and sr<n: sr=repeatRows
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   821
                elif sr>=repeatRows and sr>=n: sr=sr+repeatRows-n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   822
                if er>=repeatRows and er<n: er=repeatRows
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   823
                elif er>=repeatRows and er>=n: er=er+repeatRows-n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   824
                self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   825
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   826
    def _cr_1_0(self,n,cmds):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   827
        for c in cmds:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   828
            c = tuple(c)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   829
            (sc,sr), (ec,er) = c[1:3]
2185
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   830
            if sr in ('splitfirst','splitlast'): self._addCommand(c)
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   831
            else:
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   832
                if er>=0 and er<n: continue
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   833
                if sr>=0 and sr<n: sr=0
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   834
                if sr>=n: sr = sr-n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   835
                if er>=n: er = er-n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   836
                self._addCommand((c[0],)+((sc, sr), (ec, er))+c[3:])
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   837
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   838
    def _splitRows(self,availHeight):
2443
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   839
        n=self._getFirstPossibleSplitRowPosition(availHeight)
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   840
        if n<=self.repeatRows: return []
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   841
        lim = len(self._rowHeights)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   842
        if n==lim: return [self]
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   843
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   844
        repeatRows = self.repeatRows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   845
        repeatCols = self.repeatCols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   846
        splitByRow = self.splitByRow
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   847
        data = self._cellvalues
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   848
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   849
        #we're going to split into two superRows
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   850
        #R0 = slelf.__class__( data[:n], self._argW, self._argH[:n],
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   851
        R0 = self.__class__( data[:n], self._colWidths, self._argH[:n],
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   852
                repeatRows=repeatRows, repeatCols=repeatCols,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   853
                splitByRow=splitByRow)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   854
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   855
        #copy the styles and commands
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   856
        R0._cellStyles = self._cellStyles[:n]
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
   857
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   858
        A = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   859
        # hack up the line commands
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   860
        for op, (sc,sr), (ec,er), weight, color, cap, dash, join, count, space in self._linecmds:
2185
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   861
            if type(sr)is type('') and sr.startswith('split'):
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   862
                A.append((op,(sc,sr), (ec,sr), weight, color, cap, dash, join, count, space))
2185
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   863
                if sr=='splitlast':
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   864
                    sr = er = n-1
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   865
                elif sr=='splitfirst':
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   866
                    sr = n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   867
                    er = n
a45d3b2ebe37 Added splitfirst/last handling
rgbecker
parents: 2012
diff changeset
   868
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   869
            if sc < 0: sc = sc + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   870
            if ec < 0: ec = ec + self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   871
            if sr < 0: sr = sr + self._nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   872
            if er < 0: er = er + self._nrows
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
   873
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   874
            if op in ('BOX','OUTLINE','GRID'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   875
                if sr<n and er>=n:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   876
                    # we have to split the BOX
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   877
                    A.append(('LINEABOVE',(sc,sr), (ec,sr), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   878
                    A.append(('LINEBEFORE',(sc,sr), (sc,er), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   879
                    A.append(('LINEAFTER',(ec,sr), (ec,er), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   880
                    A.append(('LINEBELOW',(sc,er), (ec,er), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   881
                    if op=='GRID':
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   882
                        A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   883
                        A.append(('LINEABOVE',(sc,n), (ec,n), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   884
                        A.append(('INNERGRID',(sc,sr), (ec,er), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   885
                else:
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   886
                    A.append((op,(sc,sr), (ec,er), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   887
            elif op in ('INNERGRID','LINEABOVE'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   888
                if sr<n and er>=n:
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   889
                    A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   890
                    A.append(('LINEABOVE',(sc,n), (ec,n), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   891
                A.append((op,(sc,sr), (ec,er), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   892
            elif op == 'LINEBELOW':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   893
                if sr<n and er>=(n-1):
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   894
                    A.append(('LINEABOVE',(sc,n), (ec,n), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   895
                A.append((op,(sc,sr), (ec,er), weight, color))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   896
            elif op == 'LINEABOVE':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   897
                if sr<=n and er>=n:
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   898
                    A.append(('LINEBELOW',(sc,n-1), (ec,n-1), weight, color, cap, dash, join, count, space))
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   899
                A.append((op,(sc,sr), (ec,er), weight, color, cap, dash, join, count, space))
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   900
            else:
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
   901
                A.append((op,(sc,sr), (ec,er), weight, color, cap, dash, join, count, space))
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
   902
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   903
        R0._cr_0(n,A)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   904
        R0._cr_0(n,self._bkgrndcmds)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   905
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   906
        if repeatRows:
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   907
            #R1 = slelf.__class__(data[:repeatRows]+data[n:],self._argW,
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   908
            R1 = self.__class__(data[:repeatRows]+data[n:],self._colWidths,
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   909
                    self._argH[:repeatRows]+self._argH[n:],
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   910
                    repeatRows=repeatRows, repeatCols=repeatCols,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   911
                    splitByRow=splitByRow)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   912
            R1._cellStyles = self._cellStyles[:repeatRows]+self._cellStyles[n:]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   913
            R1._cr_1_1(n,repeatRows,A)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   914
            R1._cr_1_1(n,repeatRows,self._bkgrndcmds)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   915
        else:
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   916
            #R1 = slelf.__class__(data[n:], self._argW, self._argH[n:],
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
   917
            R1 = self.__class__(data[n:], self._colWidths, self._argH[n:],
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   918
                    repeatRows=repeatRows, repeatCols=repeatCols,
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   919
                    splitByRow=splitByRow)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   920
            R1._cellStyles = self._cellStyles[n:]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   921
            R1._cr_1_0(n,A)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   922
            R1._cr_1_0(n,self._bkgrndcmds)
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   923
1498
2e7cfa1159cb Copy alignments accross split (thanks R�diger M�hl <ruediger.maehl@web.de>
rgbecker
parents: 1495
diff changeset
   924
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   925
        R0.hAlign = R1.hAlign = self.hAlign
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   926
        R0.vAlign = R1.vAlign = self.vAlign
2443
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   927
        if self._spanCmds: R0._spanCmds, R1._spanCmds=self._cloneSpanCommands(n)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   928
        self.onSplit(R0)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   929
        self.onSplit(R1)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   930
        return [R0,R1]
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
   931
2443
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   932
    def _getFirstPossibleSplitRowPosition(self,availHeight):
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   933
        if self._spanCmds:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   934
            impossible={}
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   935
            for xy in self._rowSpanCells:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   936
                r=self._spanRanges[xy]
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   937
                if r!=None:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   938
                    y1,y2=r[1],r[3]
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   939
                    if y1!=y2:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   940
                        ymin=min(y1,y2) #normalize
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   941
                        ymax=max(y1,y2) #normalize
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   942
                        y=ymin+1
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   943
                        while 1:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   944
                            if y>ymax: break
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   945
                            impossible[y]=None #split at position y is impossible because of overlapping rowspan
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   946
                            y=y+1
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   947
        else:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   948
            impossible={} # any split possible because table does *not* have rowspans
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   949
        h = 0
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   950
        n = 1
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   951
        split_at = 0 # from this point of view 0 is the first position where the table may *always* be splitted
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   952
        for rh in self._rowHeights:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   953
            if h+rh>availHeight:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   954
                break
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   955
            if not impossible.has_key(n):
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   956
                split_at=n
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   957
            h=h+rh
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   958
            n=n+1
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   959
        return split_at
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   960
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   961
    def _cloneSpanCommands(self,n):
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   962
        spans0=[]
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   963
        spans1=[]
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   964
        for rng in self._spanRanges.values():
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   965
            if rng:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   966
                if rng[0:2]!=rng[2:4]:
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   967
                    x1,y1,x2,y2=rng
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   968
                    assert (x1<=x2) and (y1<=y2), "_spanRanges does contain unexpected values!"
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   969
                    assert not (y1<n and y2>=n) , "Something got wrong with _getFirstPossibleSplitRowPosition! %r" % [ys,ye,n]
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   970
                    if y1< n and y2< n: spans0.append(("SPAN",(x1,y1  ),(x2,y2  )))
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   971
                    if y1>=n and y2>=n: spans1.append(("SPAN",(x1,y1-n),(x2,y2-n)))
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   972
        return spans0,spans1
41262322cc3d tables.py: added span rows split handling & test contributed by Andre Reitz
rgbecker
parents: 2436
diff changeset
   973
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   974
    def split(self, availWidth, availHeight):
1912
c8509682e3e0 Finished off sizing logic to go with row and column
andy_robinson
parents: 1883
diff changeset
   975
        self._calc(availWidth, availHeight)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   976
        if self.splitByRow:
2012
d962f1d86a1b Allow for special case width overflows
rgbecker
parents: 1989
diff changeset
   977
            if not rl_config.allowTableBoundsErrors and self._width>availWidth: return []
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   978
            return self._splitRows(availHeight)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   979
        else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   980
            raise NotImplementedError
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
   981
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   982
    def draw(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   983
        self._curweight = self._curcolor = self._curcellstyle = None
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
   984
        self._drawBkgrnd()
1883
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   985
        if self._spanCmds == []:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   986
            # old fashioned case, no spanning, steam on and do each cell
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   987
            for row, rowstyle, rowpos, rowheight in map(None, self._cellvalues, self._cellStyles, self._rowpositions[1:], self._rowHeights):
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   988
                for cellval, cellstyle, colpos, colwidth in map(None, row, rowstyle, self._colpositions[:-1], self._colWidths):
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   989
                    self._drawCell(cellval, cellstyle, (colpos, rowpos), (colwidth, rowheight))
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   990
        else:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   991
            # we have some row or col spans, need a more complex algorithm
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   992
            # to find the rect for each
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   993
            for rowNo in range(self._nrows):
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   994
                for colNo in range(self._ncols):
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   995
                    cellRect = self._spanRects[colNo, rowNo]
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   996
                    if cellRect is not None:
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   997
                        (x, y, width, height) = cellRect
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   998
                        cellval = self._cellvalues[rowNo][colNo]
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
   999
                        cellstyle = self._cellStyles[rowNo][colNo]
eb6f902a0613 Initial try at column spanning
andy_robinson
parents: 1699
diff changeset
  1000
                        self._drawCell(cellval, cellstyle, (x, y), (width, height))
2374
66f754e27a01 tables.py: implement Eric Stephen's border drawing suggestion
rgbecker
parents: 2332
diff changeset
  1001
        self._drawLines()
2190
e925cd300e9e merging Jython-branch
dragan1
parents: 2189
diff changeset
  1002
326
159576a5816e First try at auto sizing
rgbecker
parents: 312
diff changeset
  1003
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1004
    def _drawBkgrnd(self):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1005
        nrows = self._nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1006
        ncols = self._ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1007
        for cmd, (sc, sr), (ec, er), arg in self._bkgrndcmds:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1008
            if sc < 0: sc = sc + ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1009
            if ec < 0: ec = ec + ncols
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1010
            if sr < 0: sr = sr + nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1011
            if er < 0: er = er + nrows
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1012
            x0 = self._colpositions[sc]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1013
            y0 = self._rowpositions[sr]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1014
            x1 = self._colpositions[min(ec+1,ncols)]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1015
            y1 = self._rowpositions[min(er+1,nrows)]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1016
            w, h = x1-x0, y1-y0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1017
            canv = self.canv
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1018
            if callable(arg):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1019
                apply(arg,(self,canv, x0, y0, w, h))
2392
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1020
            elif cmd == 'ROWBACKGROUNDS':
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1021
                #Need a list of colors to cycle through.  The arguments
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1022
                #might be already colours, or convertible to colors, or
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1023
                # None, or the string 'None'.
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1024
                #It's very common to alternate a pale shade with None.
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1025
                #print 'rowHeights=', self._rowHeights
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1026
                colorCycle = map(colors.toColorOrNone, arg)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1027
                count = len(colorCycle)
2397
6b3ce9559beb fixed col/row shading bug where last row or col never got shaded - reported R Revill
andy
parents: 2396
diff changeset
  1028
                rowCount = er - sr + 1
2392
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1029
                for i in range(rowCount):
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1030
                    color = colorCycle[i%count]
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1031
                    h = self._rowHeights[sr + i]
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1032
                    if color:
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1033
                        canv.setFillColor(color)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1034
                        canv.rect(x0, y0, w, -h, stroke=0,fill=1)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1035
                    #print '    draw %0.0f, %0.0f, %0.0f, %0.0f' % (x0,y0,w,-h)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1036
                    y0 = y0 - h
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1037
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1038
            elif cmd == 'COLBACKGROUNDS':
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1039
                #cycle through colours columnwise
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1040
                colorCycle = map(colors.toColorOrNone, arg)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1041
                count = len(colorCycle)
2397
6b3ce9559beb fixed col/row shading bug where last row or col never got shaded - reported R Revill
andy
parents: 2396
diff changeset
  1042
                colCount = ec - sc + 1
2392
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1043
                for i in range(colCount):
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1044
                    color = colorCycle[i%count]
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1045
                    w = self._colWidths[sc + i]
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1046
                    if color:
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1047
                        canv.setFillColor(color)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1048
                        canv.rect(x0, y0, w, h, stroke=0,fill=1)
6c59b0eb312d table color cycle changes
andy
parents: 2389
diff changeset
  1049
                    x0 = x0 +w
2393
6b3e47730acc tables.py: fix buglet in command adding
rgbecker
parents: 2392
diff changeset
  1050
            else:   #cmd=='BACKGROUND'
6b3e47730acc tables.py: fix buglet in command adding
rgbecker
parents: 2392
diff changeset
  1051
                canv.setFillColor(colors.toColor(arg))
6b3e47730acc tables.py: fix buglet in command adding
rgbecker
parents: 2392
diff changeset
  1052
                canv.rect(x0, y0, w, h, stroke=0,fill=1)
326
159576a5816e First try at auto sizing
rgbecker
parents: 312
diff changeset
  1053
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1054
    def _drawCell(self, cellval, cellstyle, (colpos, rowpos), (colwidth, rowheight)):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1055
        if self._curcellstyle is not cellstyle:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1056
            cur = self._curcellstyle
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1057
            if cur is None or cellstyle.color != cur.color:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1058
                self.canv.setFillColor(cellstyle.color)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1059
            if cur is None or cellstyle.leading != cur.leading or cellstyle.fontname != cur.fontname or cellstyle.fontsize != cur.fontsize:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1060
                self.canv.setFont(cellstyle.fontname, cellstyle.fontsize, cellstyle.leading)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1061
            self._curcellstyle = cellstyle
419
469fe11a010b Additions/Improvements to LINE CMD Splitting
rgbecker
parents: 403
diff changeset
  1062
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1063
        just = cellstyle.alignment
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1064
        valign = cellstyle.valign
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1065
        n = type(cellval)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1066
        if n in _SeqTypes or isinstance(cellval,Flowable):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1067
            if not n in _SeqTypes: cellval = (cellval,)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1068
            # we assume it's a list of Flowables
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1069
            W = []
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1070
            H = []
2189
47cb423f5f1a Make _listCellGeom more specific
rgbecker
parents: 2185
diff changeset
  1071
            w, h = self._listCellGeom(cellval,colwidth,cellstyle,W=W, H=H,aH=rowheight)
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1072
            if valign=='TOP':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1073
                y = rowpos + rowheight - cellstyle.topPadding
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1074
            elif valign=='BOTTOM':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1075
                y = rowpos+cellstyle.bottomPadding + h
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1076
            else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1077
                y = rowpos+(rowheight+cellstyle.bottomPadding-cellstyle.topPadding+h)/2.0
2463
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
  1078
            if cellval: y += cellval[0].getSpaceBefore()
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1079
            for v, w, h in map(None,cellval,W,H):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1080
                if just=='LEFT': x = colpos+cellstyle.leftPadding
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1081
                elif just=='RIGHT': x = colpos+colwidth-cellstyle.rightPadding - w
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1082
                elif just in ('CENTRE', 'CENTER'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1083
                    x = colpos+(colwidth+cellstyle.leftPadding-cellstyle.rightPadding-w)/2.0
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1084
                else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1085
                    raise ValueError, 'Invalid justification %s' % just
2463
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
  1086
                y -= v.getSpaceBefore()
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
  1087
                y -= h
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1088
                v.drawOn(self.canv,x,y)
2463
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
  1089
                y -= v.getSpaceAfter()
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1090
        else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1091
            if just == 'LEFT':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1092
                draw = self.canv.drawString
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1093
                x = colpos + cellstyle.leftPadding
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1094
            elif just in ('CENTRE', 'CENTER'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1095
                draw = self.canv.drawCentredString
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1096
                x = colpos + colwidth * 0.5
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1097
            elif just == 'RIGHT':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1098
                draw = self.canv.drawRightString
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1099
                x = colpos + colwidth - cellstyle.rightPadding
2219
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
  1100
            elif just == 'DECIMAL':
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
  1101
                draw = self.canv.drawAlignedString
5c1727997169 Multiple lines and decimal alignments now supported
andy_robinson
parents: 2200
diff changeset
  1102
                x = colpos + colwidth - cellstyle.rightPadding
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1103
            else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1104
                raise ValueError, 'Invalid justification %s' % just
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1105
            if n is StringType: val = cellval
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1106
            else: val = str(cellval)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1107
            vals = string.split(val, "\n")
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1108
            n = len(vals)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1109
            leading = cellstyle.leading
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1110
            fontsize = cellstyle.fontsize
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1111
            if valign=='BOTTOM':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1112
                y = rowpos + cellstyle.bottomPadding+n*leading-fontsize
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1113
            elif valign=='TOP':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1114
                y = rowpos + rowheight - cellstyle.topPadding - fontsize
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1115
            elif valign=='MIDDLE':
2396
9e12577b8d30 Tim Roberts' fix to vertical table cell alignment
andy
parents: 2393
diff changeset
  1116
                #tim roberts pointed out missing fontsize correction 2004-10-04
9e12577b8d30 Tim Roberts' fix to vertical table cell alignment
andy
parents: 2393
diff changeset
  1117
                y = rowpos + (cellstyle.bottomPadding + rowheight-cellstyle.topPadding+n*leading)/2.0 - fontsize
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1118
            else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1119
                raise ValueError, "Bad valign: '%s'" % str(valign)
329
7358814b9b59 First attempt at VALIGN
rgbecker
parents: 327
diff changeset
  1120
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1121
            for v in vals:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1122
                draw(x, y, v)
2463
67935cd21f54 tables.py: empty cellval patch from Jean-Francois Gosset
rgbecker
parents: 2443
diff changeset
  1123
                y -= leading
1683
7fa753e4420a Removed all trailing whitespace
andy_robinson
parents: 1677
diff changeset
  1124
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1125
# for text,
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1126
#   drawCentredString(self, x, y, text) where x is center
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1127
#   drawRightString(self, x, y, text) where x is right
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1128
#   drawString(self, x, y, text) where x is left
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1129
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1130
_LineOpMap = {  'GRID':'_drawGrid',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1131
                'BOX':'_drawBox',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1132
                'OUTLINE':'_drawBox',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1133
                'INNERGRID':'_drawInnerGrid',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1134
                'LINEBELOW':'_drawHLinesB',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1135
                'LINEABOVE':'_drawHLines',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1136
                'LINEBEFORE':'_drawVLines',
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1137
                'LINEAFTER':'_drawVLinesA', }
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1138
2194
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
  1139
class LongTable(Table):
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
  1140
    '''Henning von Bargen's changes will be active'''
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
  1141
    _longTableOptimize = 1
6bc71309eb18 Modified version of Henning von Bargen's LongTables optimisation
rgbecker
parents: 2190
diff changeset
  1142
403
05b3be301e19 Started debugging Table split
rgbecker
parents: 361
diff changeset
  1143
LINECOMMANDS = _LineOpMap.keys()
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1144
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1145
def _isLineCommand(cmd):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1146
    return cmd[0] in LINECOMMANDS
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1147
350
0916ae478b25 Table splitting start
rgbecker
parents: 342
diff changeset
  1148
def _setCellStyle(cellStyles, i, j, op, values):
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1149
    #new = CellStyle('<%d, %d>' % (i,j), cellStyles[i][j])
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1150
    #cellStyles[i][j] = new
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1151
    ## modify in place!!!
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1152
    new = cellStyles[i][j]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1153
    if op == 'FONT':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1154
        n = len(values)
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1155
        new.fontname = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1156
        if n>1:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1157
            new.fontsize = values[1]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1158
            if n>2:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1159
                new.leading = values[2]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1160
            else:
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1161
                new.leading = new.fontsize*1.2
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1162
    elif op in ('FONTNAME', 'FACE'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1163
        new.fontname = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1164
    elif op in ('SIZE', 'FONTSIZE'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1165
        new.fontsize = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1166
    elif op == 'LEADING':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1167
        new.leading = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1168
    elif op == 'TEXTCOLOR':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1169
        new.color = colors.toColor(values[0], colors.Color(0,0,0))
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1170
    elif op in ('ALIGN', 'ALIGNMENT'):
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1171
        new.alignment = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1172
    elif op == 'VALIGN':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1173
        new.valign = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1174
    elif op == 'LEFTPADDING':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1175
        new.leftPadding = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1176
    elif op == 'RIGHTPADDING':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1177
        new.rightPadding = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1178
    elif op == 'TOPPADDING':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1179
        new.topPadding = values[0]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1180
    elif op == 'BOTTOMPADDING':
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1181
        new.bottomPadding = values[0]
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1182
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1183
GRID_STYLE = TableStyle(
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1184
    [('GRID', (0,0), (-1,-1), 0.25, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1185
     ('ALIGN', (1,1), (-1,-1), 'RIGHT')]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1186
    )
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1187
BOX_STYLE = TableStyle(
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1188
    [('BOX', (0,0), (-1,-1), 0.50, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1189
     ('ALIGN', (1,1), (-1,-1), 'RIGHT')]
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1190
    )
6
eb791971b252 Added license, __version__ and Logi comment
rgbecker
parents: 0
diff changeset
  1191
LABELED_GRID_STYLE = TableStyle(
1677
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1192
    [('INNERGRID', (0,0), (-1,-1), 0.25, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1193
     ('BOX', (0,0), (-1,-1), 2, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1194
     ('LINEBELOW', (0,0), (-1,0), 2, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: 1658
diff changeset
  1195
     ('LINEAFTER', (0,0), (0,-1), 2, colors.black),
1450177dd19e Exterminated all tab characters and added a test to make sure
andy_robinson
parents: