dw::Table Class Reference

A Widget for rendering tables. More...

#include <table.hh>

List of all members.

Classes

struct Child

class TableIterator

Public Member Functions

Table (bool limitTextWidth)

~Table ()

core::Iterator * iterator (core::Content::Type mask, bool atEnd)

Return an iterator for this widget.

void addCell (Widget *widget, int colspan, int rowspan)

void addRow (core::style::Style *style)

TableCell * getCellRef ()

Static Public Attributes

static int CLASS_ID = -1

Protected Member Functions

void sizeRequestImpl (core::Requisition *requisition)

See Sizes of Dillo Widgets.

void getExtremesImpl (core::Extremes *extremes)

See Sizes of Dillo Widgets.

void sizeAllocateImpl (core::Allocation *allocation)

See Sizes of Dillo Widgets.

void resizeDrawImpl ()

Called after sizeAllocateImpl() to redraw necessary areas. By default the whole widget is redrawn.

void setWidth (int width)

void setAscent (int ascent)

void setDescent (int descent)

void draw (core::View *view, core::Rectangle *area)

void removeChild (Widget *child)

Private Types

enum { LEN_AUTO = -1, LEN_ABS = -2 }

Private Member Functions

bool childDefined (int n)

void reallocChildren (int newNumCols, int newNumRows)

void calcCellSizes ()

void forceCalcCellSizes ()

void apportionRowSpan ()

void calcColumnExtremes ()

Fills dw::Table::colExtremes, only if recalculation is necessary.

void forceCalcColumnExtremes ()

Fills dw::Table::colExtremes in all cases.

void apportion2 (int totalWidth, int forceTotalWidth)

Apportionment function for AUTO-length columns. 'extremes' comes filled, 'result' comes defined for percentage columns.

void apportion_percentages2 (int totalWidth, int forceTotalWidth)

void setCumHeight (int row, int value)

void setColWidth (int col, int value)

Private Attributes

bool limitTextWidth

bool rowClosed

int availWidth

int availAscent

int availDescent

int numRows

int numCols

int curRow

int curCol

lout::misc::SimpleVector
< Child * > * children

int redrawX

int redrawY

lout::misc::SimpleVector
< core::Extremes > * colExtremes

The extremes of all columns.

lout::misc::SimpleVector< int > * colWidths

The widths of all columns.

lout::misc::SimpleVector< int > * cumHeight

lout::misc::SimpleVector< int > * rowSpanCells

lout::misc::SimpleVector< int > * colSpanCells

lout::misc::SimpleVector< int > * baseline

lout::misc::SimpleVector
< core::style::Style * > * rowStyle

int hasColPercent

lout::misc::SimpleVector< float > * colPercents

Friends

class TableIterator

Detailed Description

A Widget for rendering tables.

Introduction

The dw::Table widget is used to render HTML tables.

Each cell is itself a separate widget. Any widget may be used, however, in dillo, only instances of dw::Textblock and dw::TableCell are used as children of dw::Table.

Sizes

General

The following diagram shows the dependencies between the different functions, which are related to size calculation. Click on the boxes for more information.

[A] In this case, the new calculation is not forced, but only done, when necessary.

[B] In this case, the new calculation is allways necessary, since [C] is the case.

[C] Whether this function is called, depends on NEEDS_RESIZE / EXTREMES_CHANGED.

Apportionment

See also:: How to Avoid Rounding Errors

Given two array $e_{i,\min}$ and $e_{i,\max}$ , which represent the column minima and maxima, and a total width $W$

, apportionment means to calculate column widths $w_{i}$ , with

$e_{i,\min} \le w_{i} \le e_{i,\max}$

and

$\sum w_{i} = W$

There are different algorithms for apportionment, a simple one is recommended in the HTML 4.0.1 specification (http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.5.2.2):

$w_{i} = e_{i,\min} + {e_{i,\max} - e_{i,\min}\over\sum e_{i,\max} - \sum e_{i,\min}} (W - \sum e_{i,\min})$

This one is used currently, but another one will be used soon, which is described below. The rest of this chapter is independent of the exact apportionment algorithm.

When referring to the apportionment function, we will call it $a_i (W, (e_{i,\min}), (e_{i,\min}))$ and write something like this:

$w_{i} = a_i (W, (e_{i,\min}), (e_{i,\max}))$

It is implemented by dw::Table::apportion.

Column Extremes

See also:: How to Avoid Rounding Errors

The sizes, which all other sizes depend on, are column extremes, which define, how wide a column may be at min and at max. They are calculated in the following way:

First, only cells with colspan = 1 are regarded:

$e_{\hbox{base},i,\min} = \max \{ e_{\hbox{cell},i,j,\min} \}$

$e_{\hbox{base},i,\max} = \max \{ e_{\hbox{cell},i,j,\max} \}$

only for cells with colspan = 1.
Then, (but not ) are calculated from cells with colspan > 1. (In the following formulas, the cell at always span from to .) If the minimal width of the column exceeds the sum of the column minima calculated in the last step:

$e_{\hbox{cell},i_1,j,\min} > \sum_{i=i_1}^{i=i_2} e_{\hbox{base},i,\min}$

then the minimal width of this cell is apportioned to the columns:
- If the minimal width of this cell also exceeds the sum of the column maxima:
  
  $e_{\hbox{cell},i_1,j,\min} > \sum_{i=i_1}^{i=i_2} e_{\hbox{base},i,\max}$
  
  then $e_{\hbox{cell},i_1,j,\min}$ is apportioned in a simple way:
  
  $e_{\hbox{span},i,j,\min} = e_{\hbox{base},i,\max} {e_{\hbox{span},i,j,\min} \over \sum_{i=i_1}^{i=i_2} e_{\hbox{base},i,\max}}$
- Otherwise, the apportionment function is used:
  
  $e_{\hbox{span},i,j,\min} = a_i (e_{\hbox{cell},i_1,j,\min}, (e_{\hbox{cell},i_1,j,\min} \ldots e_{\hbox{cell},i_2,j,\min}), (e_{\hbox{cell},i_1,j,\max} \ldots e_{\hbox{cell},i_2,j,\max}))$
After this, $e_{\hbox{span},i,\min}$ is then the maximum of all $e_{\hbox{span},i,j,\min}$ .
Finally, the maximum of both is used.
$e_{i,\min} = \max \{ e_{\hbox{base},i,\min}, e_{\hbox{span},i,\min} \}$

$e_{i,\max} = \max \{ e_{\hbox{base},i,\max}, e_{i,\min} \}$
For the maxima, there is no $e_{\hbox{span},i,\max}$ , but it has to be assured, that the maximum is always greater than or equal to the minimum.

Generally, if absolute widths are specified, they are, instead of the results of dw::core::Widget::getExtremes, taken for the minimal and maximal width of a cell (minus the box difference, i.e. the difference between content size and widget size). If the content width specification is smaller than the minimal content width of the widget (determined by dw::core::Widget::getExtremes), the latter is used instead.

If percentage widths are specified, they are also collected, as column maxima. A similar method as for the extremes is used, for cells with colspan > 1:

$w_{\hbox{span},i,j,\%} = a_i (w_{\hbox{cell},i_1,j,\%}, (e_{\hbox{cell},i_1,j,\min} \ldots e_{\hbox{cell},i_2,j,\min}), (e_{\hbox{cell},i_1,j,\max} \ldots e_{\hbox{cell},i_2,j,\max}))$

Cell Sizes

Determining the Width of the Table

The total width is

the specified absolute width of the table, when given, or
the available width (set by dw::Table::setWidth) times the specified percentage width of t(at max 100%), if the latter is given, or
otherwise the available width.

In any case, it is corrected, if it is less than the minimal width (but not if it is greater than the maximal width).

Bug:: The parentheses is not fully clear, look at the old code.

Details on differences because of styles are omitted. Below, this total width is called $W$

.

Evaluating percentages

The following algorithms are used to solve collisions between different size specifications (absolute and percentage). Generally, inherent sizes and specified absolute sizes are preferred.

First, calculate the sum of the minimal widths, for columns, where no percentage width has been specified. The difference to the total width is at max available to the columns with percentage width specifications:

$W_{\hbox{columns}_\%,\hbox{available}} = W - \sum e_{i,\min}$

with only those columns with no percentage width specification.
Then, calculate the sum of the widths, which the columns with percentage width specification would allocate, when fully adhering to them:

$W_{\hbox{columns}_\%,\hbox{best}} = W \sum w_{i,\%}$

with only those columns with a percentage width specification.
Two cases are distinguished:
- $W_{\hbox{columns}_\%,\hbox{available}} \ge W_{\hbox{columns}_\%,\hbox{best}}$ : In this case, the percentage widths can be used without any modification, by setting the extremes:
  
  $e_{i,\min} = e_{i,\max} = W w_{i,\%}$
  
  for only those columns with a percentage width specification.
- $W_{\hbox{columns}_\%,\hbox{available}} < W_{\hbox{columns}_\%,\hbox{best}}$ : In this case, the widths for these columns must be cut down:
  
  $e_{i,\min} = e_{i,\max} = w_{i,\%} {W_{\hbox{columns}_\%,\hbox{available}} \over w_{\hbox{total},\%}}$
  
  with
  
  $w_{\hbox{total},\%} = \sum w_{i,\%}$
  
  in both cases for only those columns with a percentage width specification.

( $e_{i,\min}$ and $e_{i,\max}$ are set temporarily here, the notation should be a bit clearer.)

Column Widths

The column widths are now simply calculated by applying the apportionment function.

Row Heights

...

Alternative Apportionment Algorithm

The algorithm described here tends to result in more homogeneous column widths.

The following rule leads to well-defined $w_{i}$ : All columns $i$ have have the same width $w$ , except:

$w < e_{i,\min}$ , or
$w > e_{i,\max}$ .

Furthermore, $w$ is

less than all $e_{i,\min}$ of columns not having as width, and
greater than all $e_{i,\min}$ of columns not having as width.

Of course, $\sum w_{i} = W$ must be the case.

Based on an initial value $w = {W\over n}$ , $w$ can iteratively adjusted, based on these rules.

Borders, Paddings, Spacing

Currently, DwTable supports only the separated borders model (see CSS specification). Borders, paddings, spacing is done by creating dw::core::style::Style structures with values equivalent to following CSS:

 TABLE {
   border:           outset table-border;
   border-collapse:  separate;
   border-spacing:   table-cellspacing;
   background-color: table-bgcolor;
 }

 TD TH {
   border:           inset table-border;
   padding:          table-cellspacing;
   background-color: td/th-bgcolor;
 }

Here, foo-bar refers to the attribute bar of the tag foo foo. Look at the HTML parser for more details.

Member Enumeration Documentation

anonymous enum [private]

hasColPercent becomes true when any cell specifies a percentage width. A negative value in colPercents means LEN_AUTO or LEN_ABS.

Enumerator:

LEN_AUTO
LEN_ABS

Constructor & Destructor Documentation

dw::Table::Table ( bool limitTextWidth )

dw::Table::~Table ( )

References baseline, dw::Table::Child::cell, dw::Table::Child::CELL, children, colExtremes, colPercents, colSpanCells, colWidths, cumHeight, lout::misc::SimpleVector< T >::get(), rowSpanCells, rowStyle, lout::misc::SimpleVector< T >::size(), dw::Table::Child::SPAN_SPACE, dw::Table::Child::type, and dw::core::style::Style::unref().

Member Function Documentation

void dw::Table::addCell	(	Widget *	widget,
		int	colspan,
		int	rowspan
	)

References addRow(), dw::core::style::StyleAttrs::backgroundColor, dw::Table::Child::cell, dw::Table::Child::CELL, children, curCol, curRow, lout::misc::SimpleVector< T >::get(), MAX, numCols, numRows, dw::core::Widget::queueResize(), reallocChildren(), rowClosed, rowStyle, lout::misc::SimpleVector< T >::set(), dw::Table::Child::SPAN_SPACE, dw::Table::Child::spanSpace, and dw::Table::Child::type.

void dw::Table::addRow ( core::style::Style * style )

References curCol, curRow, lout::misc::SimpleVector< T >::get(), numCols, numRows, reallocChildren(), dw::core::style::Style::ref(), rowClosed, rowStyle, lout::misc::SimpleVector< T >::set(), and dw::core::style::Style::unref().

Referenced by addCell().

void dw::Table::apportion2	(	int	totalWidth,
		int	forceTotalWidth
	)			`[private]`

Apportionment function for AUTO-length columns. 'extremes' comes filled, 'result' comes defined for percentage columns.

References availWidth, colExtremes, colPercents, colWidths, dw::core::Widget::extremes, lout::misc::SimpleVector< T >::get(), lout::misc::SimpleVector< T >::getRef(), LEN_ABS, LEN_AUTO, MAX, dw::core::Extremes::maxWidth, dw::core::Extremes::minWidth, numCols, setColWidth(), lout::misc::SimpleVector< T >::setSize(), and lout::misc::SimpleVector< T >::size().

Referenced by apportion_percentages2(), and forceCalcCellSizes().

void dw::Table::apportion_percentages2	(	int	totalWidth,
		int	forceTotalWidth
	)			`[private]`

void dw::Table::apportionRowSpan ( ) [private]

References dw::core::Requisition::ascent, dw::Table::Child::cell, children, cumHeight, dw::core::Requisition::descent, lout::misc::SimpleVector< T >::get(), dw::core::Widget::getStyle(), numCols, numRows, rowSpanCells, setCumHeight(), and lout::misc::SimpleVector< T >::size().

Referenced by forceCalcCellSizes().

void dw::Table::calcCellSizes ( ) [private]

References forceCalcCellSizes(), and dw::core::Widget::needsResize().

Referenced by sizeAllocateImpl().

void dw::Table::calcColumnExtremes ( ) [private]

Fills dw::Table::colExtremes, only if recalculation is necessary.

Bug:: Some parts are missing.

References dw::core::Widget::extremesChanged(), and forceCalcColumnExtremes().

bool dw::Table::childDefined ( int n ) [inline, private]

References children, lout::misc::SimpleVector< T >::get(), lout::misc::SimpleVector< T >::size(), dw::Table::Child::SPAN_SPACE, and dw::Table::Child::type.

Referenced by draw(), forceCalcCellSizes(), forceCalcColumnExtremes(), getCellRef(), and sizeAllocateImpl().

void dw::Table::draw	(	core::View *	view,
		core::Rectangle *	area
	)			`[protected, virtual]`

Area is given in widget coordinates.

Implements dw::core::Widget.

References dw::Table::Child::cell, childDefined(), children, cumHeight, dw::core::Widget::drawBox(), dw::core::Widget::drawWidgetBox(), lout::misc::SimpleVector< T >::get(), dw::core::Widget::getContentWidth(), dw::core::Widget::getStyle(), numRows, rowStyle, lout::misc::SimpleVector< T >::size(), and dw::core::Widget::Widget().

void dw::Table::forceCalcCellSizes ( ) [private]

Bug:: dw::Table::baseline is not filled.

References dw::core::style::absLengthVal(), apportion2(), apportion_percentages2(), apportionRowSpan(), dw::core::Requisition::ascent, availWidth, baseline, dw::Table::Child::cell, childDefined(), children, colWidths, cumHeight, curCol, dw::core::Requisition::descent, dw::core::Widget::extremes, lout::misc::SimpleVector< T >::get(), dw::core::Widget::getExtremes(), dw::core::Widget::getStyle(), hasColPercent, lout::misc::SimpleVector< T >::increase(), dw::core::style::isAbsLength(), dw::core::style::isPerLength(), dw::core::style::LENGTH_AUTO, MAX, dw::core::Extremes::maxWidth, lout::misc::min(), dw::core::Extremes::minWidth, numCols, numRows, dw::core::style::perLengthVal(), rowSpanCells, lout::misc::SimpleVector< T >::set(), setCumHeight(), lout::misc::SimpleVector< T >::setSize(), and lout::misc::SimpleVector< T >::size().

Referenced by calcCellSizes(), and sizeRequestImpl().

void dw::Table::forceCalcColumnExtremes ( ) [private]

TableCell * dw::Table::getCellRef ( )

References dw::Table::Child::cell, childDefined(), children, dw::TableCell::CLASS_ID, curCol, lout::misc::SimpleVector< T >::get(), lout::identity::IdentifiableObject::instanceOf(), numCols, and numRows.

void dw::Table::getExtremesImpl ( core::Extremes * extremes ) [protected, virtual]

See Sizes of Dillo Widgets.

Reimplemented from dw::core::Widget.

References dw::core::style::absLengthVal(), colExtremes, forceCalcColumnExtremes(), lout::misc::SimpleVector< T >::getRef(), dw::core::Widget::getStyle(), dw::core::style::isAbsLength(), MAX, dw::core::Extremes::maxWidth, dw::core::Extremes::minWidth, and numCols.

core::Iterator * dw::Table::iterator	(	core::Content::Type	mask,
		bool	atEnd
	)			`[virtual]`

Return an iterator for this widget.

mask can narrow the types returned by the iterator, this can enhance performance quite much, e.g. when only searching for child widgets.

With atEnd == false, the iterator starts before the beginning, i.e. the first call of dw::core::Iterator::next will let the iterator point on the first piece of contents. Likewise, With atEnd == true, the iterator starts after the last piece of contents, call dw::core::Iterator::prev in this case.

Implements dw::core::Widget.

References TableIterator.

void dw::Table::reallocChildren	(	int	newNumCols,
		int	newNumRows
	)			`[private]`

References dw::Table::Child::cell, dw::Table::Child::CELL, children, dw::Table::Child::colspanOrig, lout::misc::SimpleVector< T >::get(), numCols, numRows, rowStyle, lout::misc::SimpleVector< T >::set(), lout::misc::SimpleVector< T >::setSize(), dw::Table::Child::SPAN_SPACE, dw::Table::Child::spanSpace, and dw::Table::Child::type.

Referenced by addCell(), and addRow().

void dw::Table::removeChild ( Widget * child ) [protected]

Bug:: Not implemented.

void dw::Table::resizeDrawImpl ( ) [protected, virtual]

Called after sizeAllocateImpl() to redraw necessary areas. By default the whole widget is redrawn.

Reimplemented from dw::core::Widget.

References dw::core::Widget::allocation, dw::core::Widget::getHeight(), dw::core::Widget::queueDrawArea(), redrawX, and redrawY.

void dw::Table::setAscent ( int ascent ) [protected, virtual]

Reimplemented from dw::core::Widget.

References availAscent, and dw::core::Widget::queueResize().

void dw::Table::setColWidth	(	int	col,
		int	value
	)			`[inline, private]`

References colWidths, lout::misc::SimpleVector< T >::get(), lout::misc::min(), redrawX, and lout::misc::SimpleVector< T >::set().

Referenced by apportion2(), and apportion_percentages2().

void dw::Table::setCumHeight	(	int	row,
		int	value
	)			`[inline, private]`

References cumHeight, lout::misc::SimpleVector< T >::get(), lout::misc::min(), redrawY, and lout::misc::SimpleVector< T >::set().

Referenced by apportionRowSpan(), and forceCalcCellSizes().

void dw::Table::setDescent ( int descent ) [protected, virtual]

Reimplemented from dw::core::Widget.

References availDescent, and dw::core::Widget::queueResize().

void dw::Table::setWidth ( int width ) [protected, virtual]

Reimplemented from dw::core::Widget.

References availWidth, limitTextWidth, and dw::core::Widget::queueResize().

void dw::Table::sizeAllocateImpl ( core::Allocation * allocation ) [protected, virtual]

See Sizes of Dillo Widgets.

Bug:: Baselines are not regarded here.

Reimplemented from dw::core::Widget.

References dw::core::Requisition::ascent, dw::core::Allocation::ascent, calcCellSizes(), dw::Table::Child::cell, childDefined(), children, colWidths, cumHeight, dw::core::Allocation::descent, lout::misc::SimpleVector< T >::get(), dw::core::Widget::getStyle(), numCols, numRows, dw::core::Allocation::width, dw::core::Allocation::x, and dw::core::Allocation::y.

void dw::Table::sizeRequestImpl ( core::Requisition * requisition ) [protected, virtual]

See Sizes of Dillo Widgets.

Bug:: Baselines are not regarded here.

Implements dw::core::Widget.

References dw::core::Requisition::ascent, colWidths, cumHeight, dw::core::Requisition::descent, forceCalcCellSizes(), lout::misc::SimpleVector< T >::get(), dw::core::Widget::getStyle(), numCols, numRows, and dw::core::Requisition::width.

Friends And Related Function Documentation

friend class TableIterator [friend]

Referenced by iterator().

Member Data Documentation

int dw::Table::availAscent [private]

Referenced by setAscent(), and Table().

int dw::Table::availDescent [private]

Referenced by setDescent(), and Table().

int dw::Table::availWidth [private]

Referenced by apportion2(), apportion_percentages2(), forceCalcCellSizes(), setWidth(), and Table().

lout::misc::SimpleVector<int>* dw::Table::baseline [private]

Referenced by forceCalcCellSizes(), Table(), and ~Table().

lout::misc::SimpleVector<Child*>* dw::Table::children [private]

Referenced by addCell(), apportionRowSpan(), childDefined(), draw(), forceCalcCellSizes(), forceCalcColumnExtremes(), getCellRef(), dw::Table::TableIterator::next(), dw::Table::TableIterator::prev(), reallocChildren(), sizeAllocateImpl(), Table(), dw::Table::TableIterator::TableIterator(), and ~Table().

int dw::Table::CLASS_ID = -1 [static]

Reimplemented from dw::core::Widget.

Referenced by Table().

lout::misc::SimpleVector<core::Extremes>* dw::Table::colExtremes [private]

The extremes of all columns.

Referenced by apportion2(), apportion_percentages2(), forceCalcColumnExtremes(), getExtremesImpl(), Table(), and ~Table().

lout::misc::SimpleVector<float>* dw::Table::colPercents [private]

Referenced by apportion2(), apportion_percentages2(), forceCalcColumnExtremes(), Table(), and ~Table().

lout::misc::SimpleVector<int>* dw::Table::colSpanCells [private]

If a Cell has colspan > 1, it goes into this array

Referenced by forceCalcColumnExtremes(), Table(), and ~Table().

lout::misc::SimpleVector<int>* dw::Table::colWidths [private]

The widths of all columns.

Referenced by apportion2(), apportion_percentages2(), forceCalcCellSizes(), setColWidth(), sizeAllocateImpl(), sizeRequestImpl(), Table(), and ~Table().

lout::misc::SimpleVector<int>* dw::Table::cumHeight [private]

Row cumulative height array: cumHeight->size() is numRows + 1, cumHeight->get(0) is 0, cumHeight->get(numRows) is the total table height.

Referenced by apportionRowSpan(), draw(), forceCalcCellSizes(), setCumHeight(), sizeAllocateImpl(), sizeRequestImpl(), Table(), and ~Table().

int dw::Table::curCol [private]

Referenced by addCell(), addRow(), forceCalcCellSizes(), getCellRef(), and Table().

int dw::Table::curRow [private]

Referenced by addCell(), addRow(), and Table().

int dw::Table::hasColPercent [private]

Referenced by apportion_percentages2(), forceCalcCellSizes(), forceCalcColumnExtremes(), and Table().

bool dw::Table::limitTextWidth [private]

Referenced by setWidth().

int dw::Table::numCols [private]

Referenced by addCell(), addRow(), apportion2(), apportion_percentages2(), apportionRowSpan(), forceCalcCellSizes(), forceCalcColumnExtremes(), getCellRef(), getExtremesImpl(), reallocChildren(), sizeAllocateImpl(), sizeRequestImpl(), and Table().

int dw::Table::numRows [private]

Referenced by addCell(), addRow(), apportionRowSpan(), draw(), forceCalcCellSizes(), forceCalcColumnExtremes(), getCellRef(), reallocChildren(), sizeAllocateImpl(), sizeRequestImpl(), and Table().

int dw::Table::redrawX [private]

Referenced by resizeDrawImpl(), setColWidth(), and Table().

int dw::Table::redrawY [private]

Referenced by resizeDrawImpl(), setCumHeight(), and Table().

bool dw::Table::rowClosed [private]

Referenced by addCell(), addRow(), and Table().

lout::misc::SimpleVector<int>* dw::Table::rowSpanCells [private]

If a Cell has rowspan > 1, it goes into this array

Referenced by apportionRowSpan(), forceCalcCellSizes(), Table(), and ~Table().

lout::misc::SimpleVector<core::style::Style*>* dw::Table::rowStyle [private]

Referenced by addCell(), addRow(), draw(), reallocChildren(), Table(), and ~Table().

The documentation for this class was generated from the following files:

dw/table.hh
dw/table.cc


Classes
struct	Child
class	TableIterator
Public Member Functions
	Table (bool limitTextWidth)
	~Table ()
core::Iterator *	iterator (core::Content::Type mask, bool atEnd)
	Return an iterator for this widget.
void	addCell (Widget *widget, int colspan, int rowspan)
void	addRow (core::style::Style *style)
TableCell *	getCellRef ()
Static Public Attributes
static int	CLASS_ID = -1
Protected Member Functions
void	sizeRequestImpl (core::Requisition *requisition)
	See Sizes of Dillo Widgets.
void	getExtremesImpl (core::Extremes *extremes)
	See Sizes of Dillo Widgets.
void	sizeAllocateImpl (core::Allocation *allocation)
	See Sizes of Dillo Widgets.
void	resizeDrawImpl ()
	Called after sizeAllocateImpl() to redraw necessary areas. By default the whole widget is redrawn.
void	setWidth (int width)
void	setAscent (int ascent)
void	setDescent (int descent)
void	draw (core::View view, core::Rectangle area)
void	removeChild (Widget *child)
Private Types
enum	{ LEN_AUTO = -1, LEN_ABS = -2 }
Private Member Functions
bool	childDefined (int n)
void	reallocChildren (int newNumCols, int newNumRows)
void	calcCellSizes ()
void	forceCalcCellSizes ()
void	apportionRowSpan ()
void	calcColumnExtremes ()
	Fills dw::Table::colExtremes, only if recalculation is necessary.
void	forceCalcColumnExtremes ()
	Fills dw::Table::colExtremes in all cases.
void	apportion2 (int totalWidth, int forceTotalWidth)
	Apportionment function for AUTO-length columns. 'extremes' comes filled, 'result' comes defined for percentage columns.
void	apportion_percentages2 (int totalWidth, int forceTotalWidth)
void	setCumHeight (int row, int value)
void	setColWidth (int col, int value)
Private Attributes
bool	limitTextWidth
bool	rowClosed
int	availWidth
int	availAscent
int	availDescent
int	numRows
int	numCols
int	curRow
int	curCol
lout::misc::SimpleVector < Child * > *	children
int	redrawX
int	redrawY
lout::misc::SimpleVector < core::Extremes > *	colExtremes
	The extremes of all columns.
lout::misc::SimpleVector< int > *	colWidths
	The widths of all columns.
lout::misc::SimpleVector< int > *	cumHeight
lout::misc::SimpleVector< int > *	rowSpanCells
lout::misc::SimpleVector< int > *	colSpanCells
lout::misc::SimpleVector< int > *	baseline
lout::misc::SimpleVector < core::style::Style * > *	rowStyle
int	hasColPercent
lout::misc::SimpleVector< float > *	colPercents
Friends
class	TableIterator