1.156.2 Send methods

table ->append: cell=table_cell, x=[int], y=[int]

Append a cell at the given location. A default x or y is read from the table<-current attribute. Please note that table_cell<-convert wraps graphical objects into a table cell, so graphicals can be appended directly to the table.

After the table->append, table<-current is incremented to the next column on this row. If there is no next column, it will be created using table<-column. Use table->next_row to force the insertion point to the first column on the next row.

If the next column on this row points into a row-spanned cell, the insertion point will be incremented to point to the first free column after this row-spanned cell.

table ->border: 0..

Thickness of border-lines. Which lines are painted is controlled by table->rules and table->frame.

table ->compute:

Compute column and row dimensions, places the graphicals in the cells and updates the table<-area. Invoked by device->compute of the layout_manager<-device I'm associated with.

table ->compute_bounding_box:

Compute the bounding box. Called by the layout_manager<-device to set the bounding box of the layout_manager<-device (to the table<-area of the table object).

table ->delete: what=table_cell|table_row|table_column, keep=[bool]

Delete a cell, row or column. These objects are fetched using table<-cell, table<-row or table<-column. Deleting rows or columns holding spanned cells will deal naturally with these cells: There location and spanning will be updated such that they span the same set of rows/columns.

If keep is @on, the content of the row, column or cell are kept. Otherwise the content is visual->destroyed.

If a column is deleted, all cells that will be deleted from the table are attached to the table_column object. Together with table->insert_column, this allows for relocating columns if a table without loosing the table-properties. Note that the column should be object->lock_object’ed to avoid destruction by the incremental garbage collector. The following code moves column 4 to be the first column:

...
get(Table, column, 4, Col),
send(Col, lock_object, @on),
send(Tbale, delete, Col, @on),
send(Table, insert_column, 1, Col),
send(Col, lock_object, @off),
...

See also table->insert_column, table->insert_row, table->append, table_cell->row_span and table_cell->col_span.

table ->delete_rows: from=[int], to=[int], keep=[bool]

Delete a rows from the table. From defaults to the first row and to to the last one. If keep is @on the graphicals are not deleted from the device. By default they are deleted using visual->destroy.

table ->initialise:

Creates an empty table. Normally, a table is immediately associated to a device object:

...
new(D, device),
send(D, layout_manager, new(T, table)),
...

Next, columns may be specified using table<-column, and/or the table may be filled using table->append. Note that explicit definition of columns is not required.

table ->insert_column: at=int, new=table_column

Insert new column at the specified index. All columns at or to the right of this column will be moved 1 position to the right. If the column is inserted in a spanned cell, the spanning of this cell is increased by one. See also table->insert_row and table->delete.

table ->insert_row: at=int, row=[table_row]

Insert new row at the specified index. Rows with this or greater index will be moved down. Cells spanning this row will have their table_cell<-row_span incremented. See also table->insert_column and table->delete.

table ->next_row: end_group=[bool]

Modifies table<-current to point to the first column of the next row. Used together with table->append to fill the table left-to-right, row-by-row.

table ->place_cells:

Called by table->compute to deal with the actual placement of the graphicals in the cells.

table ->selection: table_cell|chain*

Specify the selected cell or cells. There is yet no possibility to select a row or column as a unit.

Please note that selecting a table_cell object is different from selecting the graphical image of the cell in the associated layout_manager<-device.

See also table<-selection.

table ->sort_rows: compare=code, from=[int], to=[int]

Sort rows in indicated range. Default is to sort all rows in the table object. This ranged may be narrowed using the optional From and To arguments. See vector->sort for details.

In the current implementation, none of the sorted rows is allowed to contain cells with row-spanning (see table_cell->row_span) larger than 1. If such cells are encountered, the error spanned_row is raised.

table ->stretched_column: column=table_column, width=int

[Virtual] A column has been stretched to this width. This method may be defined to adjust the content of the affected cells.

See also table->stretched_row.

table ->stretched_row: column=table_row, height=int

[Virtual] A row has been stretched to this width. See table->stretched_column for details.

table ->width: [0..]

Total width of the table. If @default, the width is computed from the desired widths of the columns. If specified, the columns are distributed over the given width.

See also table_slice->rubber.