Objects of this class collect all settings pertaining to tables.

By default unless a table exactly fits a frame PTC ALD will position it flush left within it. You can change the position of the table (as long as it is smaller than the frame) by using horizontalAlign.

The HorizontalAlignment enumeration has the following constants of type DOMString.

In Version One Tables, tables were unable to overflow either columns or pages. The text in tables would start to flow from one cell to the next rather than the table breaking and restarting. In Version Two Tables, if a table overflows in either circumstances it will break as a whole and restart by default.

The OverflowMode enumeration has the following constants of type int.

When a table flows from one column to the next, or from one page to the next, the row number will continue. Thee constants can be used with fTable.overflowRowZero to control if and how the row number gets reset.

The primary row number is used internally and identifies the row within the table.

The secondary row number (new in PTC ALD 10.0 M050) is not used internally, but is incremented with the primary row number. This number can be used in Rules and Backgrounds to control their look.

Use fTable.ZERO_PRIMARY + fTable.ZERO_SECONDARY to reset both row numbers.

The RowZeroMode enumeration has the following constants of type int.

The priority on keeps used within tables, usable with keepWithNext, keepWithPrevious and keepTogether. The same settings are also used by rowWidowPriority and rowOrphanPriority.

The KeepPriorities enumeration has the following constants of type int.

PI: tbabsend

This property can be used to control where the right edge of a table is measured from. Specifying true controls where the right hand edge of the table is measured from and only has an effect for a table that is nested within another table or block.

Normally in a nested table its edges are measured from the inside of the parent cell's rules after also taking into account any cell padding.

Searching back through the hierarchy of parent tables and blocks, if one is found with more than a single column, or one had its number of columns specified explicity, then when absoluteStart = true the table will be measured from the border of that parents column edge. This will still be inside any rules of the parent cell but will ignore any of its cell padding. If no conforming parent table/block exists then absoluteStart = true will measure directly from the frame column boundary. From this right boundary, the current table's right margin will then be applied, along with table rules and padding etc in the normal way.

PI: tbabsstart

This property can be used to control where the left edge of a table is measured from. Specifying true controls where the left hand edge of the table is measured from and only has an effect for a table that is nested within another table or block.

Normally in a nested table its edges are measured from the inside of the parent cell's rules after also taking into account any cell padding.

Searching back through the hierarchy of parent tables and blocks, if one is found with more than a single column, or one had its number of columns specified explicity, then when absoluteStart = true the table will be measured from the border of that parents column edge. This will still be inside any rules of the parent cell but will ignore any of its cell padding. If no conforming parent table/block exists then absoluteStart = true will measure directly from the frame column boundary. From this left boundary, the current table's left margin will then be applied, along with table rules and padding etc in the normal way.

PI: tbbreaks

With old version 1 Tables, they weren't allowed to break over columns and pages, so when a column break or table break was encountered inside a table, it wasn't treated as such and instead terminated the table. This is still the default case for version 1 tables and corresponds to allowBreaks = false.

Version 2 tables default to allowBreaks = true, which means that column breaks and pages breaks will do as you'd expect, but will remain ‘inside' the table. If you want the col and page breaks to do what they did for version 1 tables, then set allowBreaks = false.

PI: tbavoidall

PI: tbavoidclear

PI: tbavoidme

PI: tbavoidnone

PI: tbavoidpreserve

PI: tbbgc

It is possible to assign a colour to the entire table, using backgroundColor. You must specify a colour with the command, this will then be applied to the table. You will only see the table background colour if cells have no colour assigned or where gutters occur in the table.

PI: tbcolsets

Specifies column set display definitions.

Instead of automatically letting PTC ALD work out the sets of columns to use when duplicating a table, you can specify them manually. These sets of columns will then be used if the table is too wide for the frame column, or if widthMode = 2 is used. Each colset is a list of columns to include, separated by commas. You can specify as many colsets as you need. i.e. table.columnSets = '(0,1,2,3),(0,4,5),(0,6,7)' will produce three copies of the table instead of one very wide table with 8 columns.

PI: tbspanspec

Column span specifications for the tabse.

This property contains an array of column span specifications, accessible by their names. When starting a cell using fFormatting::tableCellStart, the name of a span specification may be used instead of giving starting and ending column numbers or names.

The individual columns of the table. If you specify the number of columns in numColumns, there will be just as many items available in this array.

If the number of columns is left unspecified, this array will grow as needed to accomodate the columns of the table, up to the maximum number of columns supported by PTC ALD (currently 200). In this case, the last column object from the array on which any properties are defined will be repeated for all the remaining columns required by the data in the table.

This object represents the default settings for cells in this table.

This object represents the default settings for rows in this table.

PI: tbfnote

Specifies a footnote control stream for table footnotes.

When a footnote control stream specifying sidenotes is applied to a table, the columns of the table will behave like the columns in a frame.

This can be used in conjunction with fTableColumn::reserve, which will reserve the relevant columns for the placement of sidenotes.

If a footnote reference is processed inside a table and that table does not have a footnote control stream, then the footnote control stream of the frame containing the table is applied. Similarly if a footnote is placed in a nested table which has no footnote control stream, then the parent table's footnote control stream is used, if it exists, else that of the frame.

PI: tbrulefc

Only relevant when used in conjunction with spanAvoid = true. If true, then table-columns on the left of frame-columns will return true for (?l) or [l] when specified as the conditions for cell rules/background colours. Works similarly for right hand edges and (?r) or [r].

If you want to use this but still need to detect for a real left column, then use an explicit test of (x=1). Detecting for a real right hand columns requires you to know the number of columns in advance and use (x=5) for a 5 column table for instance.

PI: tbgutl

As well as being able to add gutters between the columns in the table, you can add gutters outside columns and inside table rules. There are two properties for this, use gutterLeft to add a left gutter and gutterRight to add a right gutter to the table. For each of these commands, you can either specify a fixed width (e.g. table.gutterLeft = '20mm') or specify that you want a relative width (e.g. table.gutterLeft = '1*').

PI: tbgutr

As well as being able to add gutters between the columns in the table, you can add gutters outside columns and inside table rules. There are two properties for this, use gutterLeft to add a left gutter and gutterRight to add a right gutter to the table. For each of these commands, you can either specify a fixed width (e.g. table.gutterLeft = '20mm') or specify that you want a relative width (e.g. table.gutterLeft = '1*').

PI: tbhkeeptog

If true, specifies that any header rows for the table will automatically be kept together.

PI: tbfmth

Specifies table format criteria.

PI: tbfmthdir

This effects the alignment of the table within it's parent column is useful in Arabic systems or any other language which reads from right to left. If horizontalProgression is 1, the system will transpose left and right settings of the horizontalAlign property. This will only affect tables which are smaller than the parent column. See also progression.

PI: tbigfill

By default when using frame fillers, any vertical space where text could be vertically justified is potential area to be filled. This includes space at the bottom of cells that are not the deepest within their row.

Using ignoreFillers = true will restrict the fillers and stop this space at the bottom of cells from being filled.

PI: tbignrw

If false then table rules extend into the table and their width reduces the amount of space for content. If true then the width of any table rules are ignored and they are drawn centred on the table boundary.

PI: tbkeeptog

Specifies that the contents of the table is kept together, using the priorities in the same way other table keeps work

This is a column based keep and ensures that the table is kept within the same parent column, be it either a frame column, a slim table column or a block column.

PI: tbkeep

This can be used to keep the end of a table with the item following it, with the priority behaving in a similar way to paragraph keeps. How much of the table is kept with the next item, depends on the overflow mode of the table, widows and orphans and any row keeps etc. All that this ensures is that the very last thing within the table is kept.

This is a column based keep and ensures that the item is kept within the same parent column, be it either a frame column, a block column or a slim table column.

You cannot keep from the end of a multi-column balance to the next item, because by definition they will be in different columns.

PI: tbkeepp

Specifies that the start of this table is kept with the previous item, using the priorities in the same way that paragraph keeps work How much of the table this keeps is dependant on the overflow mode in use and whether any row keeps are also in use etc.

This is a column based keep and ensures that the item is kept within the same parent column, be it either a frame column, a block column or a slim table column.

You cannot keep with the end of a multi-column balance from the next item, because by definition they will be in different columns.

PI: tbma

This property sets the top, bottom, left and right margins to the given size.

PI: tbmb

It is possible to add margins to the outside of the table, in this way you can adjust the table position relative to the text surrounding it. With all the table margin commands you need to add a value (height or width) for the margin you require e.g. table.marginBottom = '20mm' would add a 20mm margin under the table.

PI: tbmbp

Priority for bottom margin.

PI: tbmct

Margin at the top of each column.

PI: tbmctp

Priority for column top margin.

PI: tbmdt

This allows you to specify a top drop which will occur whenever a table is at the top of a column. The definition of column top is the same used for paragraph column top margins. This means the top of a frame column, the top of a cell when the parent table is of overflow type 3 or <?tbsimcol> has been used, or following a "break across columns". Note that this top drop is in addition to either marginTop or marginColumnTop and occurs mid-table as well as at the top of a table. This in particular gives you control over where headers occur in relation to the top of a column.

PI: tborientm

If true, the values for marginTop, marginLeft, marginBottom and marginRight will be adjusted so they follow the orientation of the table.

PI: tbml

It is possible to add margins to the outside of the table, in this way you can adjust the table position relative to the text surrounding it. With all the table margin commands you need to add a value (height or width) for the margin you require e.g. table.marginLeft = '20mm' would add a 20mm margin left of the table.

PI: tbmmid

Specifies the height of the margin between duplicate sets of a table: the default value is 0.

PI: tbmr

It is possible to add margins to the outside of the table, in this way you can adjust the table position relative to the text surrounding it. With all the table margin commands you need to add a value (height or width) for the margin you require e.g. table.marginRight = '20mm' would add a 20mm margin right of the table.

PI: tbmt

It is possible to add margins to the outside of the table, in this way you can adjust the table position relative to the text surrounding it. With all the table margin commands you need to add a value (height or width) for the margin you require e.g. table.marginTop = '20mm' would add a 20mm margin above the table.

PI: tbmtmodea

By default tables following a break across will use a column top margin. Setting this to true will cause the table to use normal top margins in this situation instead.

PI: tbmtmodet

By default tables following a table will use a column top margin. Setting this to true will cause the table to use normal top margins in this situation instead.

PI: tbmtp

Priority for top margin.

PI: tbmtspan

Setting this to true, will cause table top or column top margins specified after a span, to themselves span as well.

PI: tbmustfit

If true, specifies that this table must fit and so it will overlap with a warning if it doesn't.

An expected use would be for a rotated table within a parent table column, to ensure that the rotated content will fit, even if the parent column is too narrow.

A name can be given to the table in order to make it easier to determine which table is being started and ended using the tableStart() and tableEnd() routines and to determine which table object is being formatted.

PI: tbnsshow

When table headers and footers are being skipped (using mode 2), then by default any changes to the showstring counters are also skipped/ignored.

With noSkipCounters = true then the showstring counters are not-skipped but flow through to the main body of the table.

PI: tbcoln

By default, 3B2 will count the number of columns within a table by pre-scanning it, if either no columns were specified or if they were specified using fTableColumn::width as opposed to the old, version 1, < ?tbcols> PI. This has the disadvantage that you need to include explicit row break commands, when you want to start a new row. Using numColumns you can explicitly state the number of columns within the table, and cells will wrap onto new rows automatically. The final number of columns in the table is determined from numColumns as follows:

If you set numColumns to explicitly define a number of columns then any tables nested within this table, will use its column edges if absoluteStart or absoluteEnd are true.

Slim tables of overflow = 3 flow content from one column to the next and so cannot be prescanned to count the number of columns. The number of columns must be specified explicitly.

PI: tbrown

This specifies the number of rows in the table. This is only required for fTable.rowWidows, and if it is not specified, fTable.rowWidows will be ignored.

PI: tborient

This property is used to rotate a table 90 degrees counter clockwise. This is a particularly useful function if the table is too wide for the frame. Using orientation you can rotate a table so that it is presented in a landscape view that fits the dimensions of the frame.

PI: tbovflow

Specifies table overflow mode, as described in OverflowMode.

PI: tbovrowz

When a table overflows from one page to the next, or one column to the next, then the appropriate row number will be reset to zero when the table restarts. See fTable.RowZeroModes.

PI: tbpadb

Amount of padding at the bottom of the table.

PI: tbpadl

Amount of padding left of the table.

PI: tbpadr

Amount of padding right of the table.

PI: tbpadt

Amount of padding at the top of the table.

PI: tbposreset

PI: tbprescan

With Version 2 tables, 3B2 will normally pre-scan the data for the table, to determine how many columns there are and to pick up width information about the columns. The exception to this is when the user has specified the number of columns, and all their widths, either using the version-1 lump style attribute or a combination of numColumns and columns[].width properties at the start of the table. In these cases, 3B2 skips the pre-scan to save time.

Unfortunately, 3B2 also uses the pre-scan to pick up the position of the start of footers, (and other information in the future), and so to make the footers work, you will need to prescan = true to force 3B2 to do a pre-scan anyway.

PI: tbdir

This effects the progression direction of the columns within the table. The columns normally flow left to right, but setting progression = 1 the columns will flow from right to left instead. This means that both the data and the column definition will start in the column on the right.

N.B. This does not mean that the text within the cells will flow from right to left; to achieve that as well, the paragraph needs to be told to work right to left too, which is done using currentParagraph.direction = 1.

PI: tbreshow

When a table overflows a page and headers and footers etc. are inserted then by default the showstring counters flow through from the main body of the table. If resetCounters is non-zero, then when 3B2 re-inserts the header, the showstring counters are put back to the values that they had when the header was first encountered and stored. The header is then formatted and then the counters are restored to the value they had ready for the rest of the body of the table.

N.B. This includes restoring the value of the show string counters for the current page number. So within the header the page number being displayed will be the page on which the header was defined.

When using column and frame references there is a potential clash with any table headers and particularly when using resetCounters = 1. The column and frame references are inserted within the context of the header, so will pick up the header's show string counters, will modify those counters for the duration of the header, and then those changes will be discarded for the main body of the table and any text afterwards. To add more flexibility in this situation, from version 8.10s, resetCounters can also take the value 2. When setting resetCounters = 2, the header is still formatted within its original context and counters, but the frame and column references get given the counters from the main body of the table, and any changes they make are then carried over into the main body of the table after the header finishes.

Added num[,slot] option from version 8.11q, which only applies if num is non-zero. slot is allowed to take a value from 1-5 which has two corresponding effects:

The point of these options is to allow the header to pick up the counters it had when it was originally defined so that it formats as expected; but also to allow the header to make changes within the body of the table - ie to increment a count for each header displayed. The expected use is that for any counter changes that the header needs to make for the body of the table, the following actions will be done:

Added num[,slot][,f] option from version 11.m050, which only applies if num is non-zero. This allows any footnote counters to be carried through the header, even if all the rest of the counters are being recalled from their value when the header was defined. This applies to standard counters: "fklmn" If you're going to place a footnote inside a repeated header, this prevents the footnote counter from resetting each time it's encountered, and works in combination with combining identical footnotes if the header is likely to appear multiple times on a single page.

PI: tbrfill

This feature or command has not been fully implemented in 3B2 or is still under development for a future release. Use of this feature or command is done so entirely at your own risk before notification of full implementation in the release notes or documentation.

Table Line padding. When there is a need for more cells in a table to fill a line, rowFill will add more cells so that a line is full. The cells generated by PTC ALD use, if it exists, the empty cell reference declared with fTableCell::emptyReference.

PI: tbrorp

Sets the priority of the rowOrphans. Orphans are the first rows of a table which occur at the bottom of a column or page. See KeepPriorities.

PI: tbror

The rowOrphans attribute enables you to define the minimum number of orphan rows for the current table. Orphans are the first rows of a table which occur at the bottom of a column or page.

PI: tbrorx

This option determines when the orphans are applied to tables. If false (the default), the orphans are only applied to the first rows in the table. If true, the orphans are applied to the first rows in any portion of the table where it overflows.

PI: tbrskipmode

Specifies the required syntax and behaviour when a row is entirely spanned by cells in earlier rows. By default, these are not specified, in the same way that cells that are spanned aren't specified. But when rowSkipMode is true, each of the skipped rows must still have its corresponding row-start and first cell-start, just so that these can then be ignored/skipped. This mode matches the behaviour of FOSI, editor and Excel and defaults to true for PTC ALD in the Styler template.

PI: tbrwidp

Sets the priority of the rowWidows. Widows are the last rows of a table which overflow to the top of a column or page. See KeepPriorities.

PI: tbrwid

The rowWidows attribute enables you to define the minimum number of widows rows for the current table. Widows are the last rows of a table which overflow to the top of a column or page.

The number of rows in the table must be specified using fTable.numRows for row widows to be used.

PI: tbbotr

When a table flows over from one page to the next, or one column to the next, by default the bottom rule around the whole table is not included where the table broke. When true, this property forces the bottom rules to be displayed.

PI: tbtopr

When a table flows over from one page to the next, or one column to the next, by default the top rule around the whole table is not re-inserted where the table broke. When true, this property forces the top rules to be displayed.

PI: tbrules

This property is used to specify table rules. It is similar to fTableCell::rules (table cell rules), except that the flags are the rules or corners to use and not conditions. Previously, in Version One Tables, adding table rules meant having to specify a table style paragraph lump.

PI: tbsimcol

In normal tables, the top of each cell is treated like the top of a column, in that paragraph column top margins will be used. However, this does not allow fParagraph::topDrop to be used and if you overflow the cell, column top margins won't apply after the break. When using overflow = 3 for slim tables, it is designed to simulate frame columns and so as well as flowing from one column to the next on overflows, it also works with fParagraph::topDrop and follows the behaviour of normal text at the top of each cell, as if it was at the top of a column; including broken cells.

Setting simulateColumns = 1 allows normal non-slim tables to also simulate column tops at the top of each cell and when breaking and hence also allows fParagraph::topDrop to be used.

When specifying simulateColumns = 2 it works in the same way as simulateColumns = 1 but only applies to cells that are themselves at the top of a frame column. See marginColumnTop and marginDropTop for definition of what is at the top of a frame column and note that the use of simulateColumns allows this definition to cascade down a series of nested tables.

When using simulateColumns = 2 within a boxhead the behaviour is slightly different, as the expected use is to try and align content with the top of a column and within a boxed row the top of cells don't necessarily align with each other. Therefore within the boxhead, fParagraph::topDrop doesn't get applied to each individual cell, but is applied as a one-off to the whole boxed row. This is done by picking up the value of fParagraph::topDrop for the highest cell within the row and using this as a vertical shift for the whole row.

When specifying simulateColumns = 3 it works in the same way as simulateColumns = 1 allowing the use of fParagraph::topDrop, but normal top margins are used instead of using column top margins. This will then also cascade into nested tables or blocks at the top of the cell.

N.B. This does mean that if your cells have top rules, then fParagraph::topDrop won't be seen to have its usual effect.

Blocks: default to simulateColumns = 2 unless numColumns is set explicitly, at which point they use simulateColumns = 1 instead. The basic principle is that if the block is being used to define columns, then they will be treated as such.

PI: tbskipegut

By default for new tables, no column gutter is allowed after the right hand column, and if you want a gutter there set the gutterRight property, and similarly the gutterLeft property on the left.

The skipEndGutter property can be used to override this and has a default value of true for new tables and false for old tables. Even when skipEndGutter = false a gutter is only after the right hand column if the gutter is specified explicitly, and was not implied by repeating the fTableColumn::gutter properties. (i.e. in a three column table, if you want a gutter on the right hand column, you must set 3 separate columns[].gutter properties and not just one, with repeat.

PI: tbamode

Avoid mode for frame gutters. This command is only relevant when used in conjunction with spanColumns. If spanAvoid is set to true then PTC ALD will try and fit the table columns within the frame columns whilst avoiding the frame gutters. Only if this is infeasible will Arbortext PTC ALD ignore this command and break across the frame columns in the normal manner, irrespective of the frame gutters.

PI: tbacross

Allows the table to break across columns within the frame. If true, the table will break across columns and if false it won't. If spanColumnsNum is unspecified, then the table will default to breaking across all the columns in the frame.

When specified within a table that is nested within a parent slim table of overflow = 3 or within a parent multi column block, this will span across the parents columns.

If the columns being spanned are also being balanced this will delineate the balance regions.

In the same way as fParagraph::spanColumns, content following a table that breaks across columns, will have the column top margin applied instead of the normal top margin.

PI: tbacross

If spanColumns is true, the table will break across columns and if false it won't. The value of spanColumnsNum specifies how many columns to break across; if unspecified, then the table will default to breaking across all the columns in the frame.

PI: tbspanframe

Allows the table to break across all columns within the frame. If true, the table will break across all columns and if false it won't.

Unlike spanColumns, this will always result in the table spanning the full frame column.

PI: tbspread

If a width is specified for the table, and the sum of all the columns and gutters etc. falls short of this width, then if spreadColumns is true the columns will all be expanded in proportion to their widths to make up the shortfall.

Note: this is the last stage in calculating column widths, and if there are any relative widths specified for either the columns or gutters, they will have swallowed up all remaining space.

PI: tbabsvj

This works in exactly the same way as fParagraph::vjAbsolute and ensures that any table vertical margins specified are absolute limits to how much stretch can be applied.

PI: tbfvj

This property specifies always 'Force Vertical Justification'. Vertical justification lets you pad out the text in a table to fill the full column depth.

PI: tbvjmgut

Space between rows of the table.

PI: tbvjpgut

Priority for space between rows of the table.

PI: tbfvjl

If there is less than the specified height left at the bottom of the column, then vjLimit will cause the whole table to VJ.

PI: tbvjmbot

Space below the table, which is ignored if the table is the last thing in the column.

PI: tbvjpbot

Priority for space below the table, which is ignored if the table is the last thing in the column.

PI: tbvjmctop

Space above the table when the table is the first thing in a column.

PI: tbvjpctop

Priority for space above the table when the table is the first thing in a column.

PI: tbvjmrow

Space below the text in the row, which effectively makes each cell deeper. This will mean that if the text is vertically centred, flushed to bottom or VJ'ed itself, then it will use this extra space.

PI: tbvjmrowb

Space below the text in each cell, but above any bottom cell rules. The text will not expand into this space, as it does with vjMarginRow.

PI: tbvjprowb

Priority for Space below the text in each cell, but above any bottom cell rules. The text will not expand into this space, as it does with vjMarginRowPriority.

PI: tbvjprow

Priority for space below the text in the row, which effectively makes each cell deeper. This will mean that if the text is vertically centred, flushed to bottom or VJ'ed itself, then it will use this extra space.

PI: tbvjmrowt

Space below any top rules in a cell, but above the text. The text will not ignore this space when vertically centring, VJ'ing etc.

PI: tbvjprowt

Priority for space below any top rules in a cell, but above the text. The text will not ignore this space when vertically centring, VJ'ing etc.

PI: tbvjmrbot

Space between the last row of the table and the table bottom rules.

PI: tbvjprbot

Priority for space between the last row of the table and the table bottom rules.

PI: tbvjmrctop

Space between the table top rule and the first row when the table is the first thing in a column.

PI: tbvjprctop

Priority for space between the table top rule and the first row when the table is the first thing in a column.

PI: tbvjmrtop

Space between the table top rule and the first row when the table is not the first thing in a column.

PI: tbvjprtop

Priority for space between the table top rule and the first row when the table is not the first thing in a column.

PI: tbvjmtop

Space above the table when the table is not the first thing in a column.

PI: tbvjptop

Priority for space above the table when the table is not the first thing in a column.

PI: tbw

If you do not enter a width for the table, PTC ALD will work it out by calculating the columns, gutters and rules within it. This may give unpredictable results, therefore it is advisable to specify a width.

PI: tbwcalc

Specifies the algorithm used when calculating the column widths, but only has any effect when the contents of cells spanning multiple columns are wider than the sum of the columns they span. The current methods implemented for num are as follows:

N.B.

PI: tbhcalc

This only has any effect when fTableCell::widthMode or fTableColumn::widthMode are set to true . It effects the method that 3B2 will use to determine how to allocate space to columns, when there is enough space for all minimum measured column widths to be used, but not enough for maximum measured widths. This works in conjunction with widthCalc if the table contains cells that span columns. The values of code are as follows:

When pre-scanning to measure the column widths, by default 3B2 limits the width of any column to the maximum width of the frame/table. By setting wide_mode to 1, 3B2 will measure any columns as wide as possible. This has the effect of increasing the priority given to columns containing long paragraphs.

N.B.

PI: tbwmode

When a table is too wide for a frame column, by default it just takes up the space that it needs. widthMode lets you specify alternative behaviours as follows:

PI: tbwref

widthReference lets you specify a series of alternate width references and breaks to use when the table is too wide to fit within the current measure. Each option will be tried in turn until the resulting table either fits within the measure or until there are no more options to try.

When specifying widthReference = '[b] "ref1" [, [b] "ref2" [, [b] "ref3" ...] ]' , each reference ref1, ref2, ref3 etc is simply a text tag which contains relevant table PIs. You must always specify at least one reference, although it doesn't make sense to specify less than two; and you can specify as many as you want. Whilst working out the width of the table and columns, the table preamble will be formatted multiple times using ref1 the first time and then each subsequent time including the next reference in the sequence. This may include prescanning the table multiple times if necessary, so be aware of speed implications. As well as the references themselves you can optionally include b parameters, but these must always be followed by a reference. They allow you to break to a new column for b1 or page for b2 before trying the new reference.

As an example:

By default this will create a table using reference "w1" where all the columns are measured with an extra 1mm padding and have a 5mm gutter between them. If that doesn't fit we will try reference "w2" where we've reduced the gutter to 2mm and reduced the text height to 10pt by passing the relevant attribute to an assumed fTableCell::paraReference (this could also have used a completely different paraReference instead). If that still doesn't fit then the table will break to a new page because of the 'b2' option and will then use reference "w3" which will rotate the table 90 degrees anticlockwise.

Create a new fTable object.

Return the object corresponding to the given serialized representation.

Create a serializable representation of this object.