html_table.cpp
// --------------------------------------------------------------------------
#include "dom/html_misc.h"
#include "dom/html_table.h"
#include "dom/dom_exception.h"
#include "html/html_miscimpl.h"
#include "html/html_tableimpl.h"
#include "misc/htmlhashes.h"
using namespace DOM;
HTMLTableCaptionElement::HTMLTableCaptionElement() : HTMLElement()
{
}
HTMLTableCaptionElement::HTMLTableCaptionElement(const HTMLTableCaptionElement &other) : HTMLElement(other)
{
}
HTMLTableCaptionElement::HTMLTableCaptionElement(HTMLTableCaptionElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableCaptionElement &HTMLTableCaptionElement::operator = (const Node &other)
{
assignOther( other, ID_CAPTION );
return *this;
}
HTMLTableCaptionElement &HTMLTableCaptionElement::operator = (const HTMLTableCaptionElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableCaptionElement::~HTMLTableCaptionElement()
{
}
DOMString HTMLTableCaptionElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableCaptionElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
// --------------------------------------------------------------------------
HTMLTableCellElement::HTMLTableCellElement() : HTMLElement()
{
}
HTMLTableCellElement::HTMLTableCellElement(const HTMLTableCellElement &other) : HTMLElement(other)
{
}
HTMLTableCellElement::HTMLTableCellElement(HTMLTableCellElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableCellElement &HTMLTableCellElement::operator = (const Node &other)
{
if( other.elementId() != ID_TD &&
other.elementId() != ID_TH )
{
if ( impl ) impl->deref();
impl = 0;
} else {
Node::operator = (other);
}
return *this;
}
HTMLTableCellElement &HTMLTableCellElement::operator = (const HTMLTableCellElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableCellElement::~HTMLTableCellElement()
{
}
long HTMLTableCellElement::cellIndex() const
{
if(!impl) return 0;
return ((HTMLTableCellElementImpl *)impl)->cellIndex();
}
void HTMLTableCellElement::setCellIndex( long /*_cellIndex*/ )
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
DOMString HTMLTableCellElement::abbr() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ABBR);
}
void HTMLTableCellElement::setAbbr( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ABBR, value);
}
DOMString HTMLTableCellElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableCellElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLTableCellElement::axis() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_AXIS);
}
void HTMLTableCellElement::setAxis( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_AXIS, value);
}
DOMString HTMLTableCellElement::bgColor() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
}
void HTMLTableCellElement::setBgColor( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
}
DOMString HTMLTableCellElement::ch() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
}
void HTMLTableCellElement::setCh( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
}
DOMString HTMLTableCellElement::chOff() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
}
void HTMLTableCellElement::setChOff( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
}
long HTMLTableCellElement::colSpan() const
{
if(!impl) return 0;
return ((ElementImpl *)impl)->getAttribute(ATTR_COLSPAN).toInt();
}
void HTMLTableCellElement::setColSpan( long _colSpan )
{
if(impl) {
DOMString value(QString::number(_colSpan));
((ElementImpl *)impl)->setAttribute(ATTR_COLSPAN,value);
}
}
DOMString HTMLTableCellElement::headers() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_HEADERS);
}
void HTMLTableCellElement::setHeaders( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_HEADERS, value);
}
DOMString HTMLTableCellElement::height() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_HEIGHT);
}
void HTMLTableCellElement::setHeight( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_HEIGHT, value);
}
bool HTMLTableCellElement::noWrap() const
{
if(!impl) return false;
return !((ElementImpl *)impl)->getAttribute(ATTR_NOWRAP).isNull();
}
void HTMLTableCellElement::setNoWrap( bool _noWrap )
{
if(impl)
((ElementImpl *)impl)->setAttribute(ATTR_NOWRAP, _noWrap ? "" : 0);
}
long HTMLTableCellElement::rowSpan() const
{
if(!impl) return 0;
return ((ElementImpl *)impl)->getAttribute(ATTR_ROWSPAN).toInt();
}
void HTMLTableCellElement::setRowSpan( long _rowSpan )
{
if(impl) {
DOMString value(QString::number(_rowSpan));
((ElementImpl *)impl)->setAttribute(ATTR_ROWSPAN,value);
}
}
DOMString HTMLTableCellElement::scope() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_SCOPE);
}
void HTMLTableCellElement::setScope( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_SCOPE, value);
}
DOMString HTMLTableCellElement::vAlign() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
}
void HTMLTableCellElement::setVAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
}
DOMString HTMLTableCellElement::width() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
}
void HTMLTableCellElement::setWidth( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
}
// --------------------------------------------------------------------------
HTMLTableColElement::HTMLTableColElement() : HTMLElement()
{
}
HTMLTableColElement::HTMLTableColElement(const HTMLTableColElement &other) : HTMLElement(other)
{
}
HTMLTableColElement::HTMLTableColElement(HTMLTableColElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableColElement &HTMLTableColElement::operator = (const Node &other)
{
if( other.elementId() != ID_COL &&
other.elementId() != ID_COLGROUP )
{
if ( impl ) impl->deref();
impl = 0;
} else {
Node::operator = (other);
}
return *this;
}
HTMLTableColElement &HTMLTableColElement::operator = (const HTMLTableColElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableColElement::~HTMLTableColElement()
{
}
DOMString HTMLTableColElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableColElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLTableColElement::ch() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
}
void HTMLTableColElement::setCh( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
}
DOMString HTMLTableColElement::chOff() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
}
void HTMLTableColElement::setChOff( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
}
long HTMLTableColElement::span() const
{
if(!impl) return 0;
return ((ElementImpl *)impl)->getAttribute(ATTR_SPAN).toInt();
}
void HTMLTableColElement::setSpan( long _span )
{
if(impl) {
DOMString value(QString::number(_span));
((ElementImpl *)impl)->setAttribute(ATTR_SPAN,value);
}
}
DOMString HTMLTableColElement::vAlign() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
}
void HTMLTableColElement::setVAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
}
DOMString HTMLTableColElement::width() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
}
void HTMLTableColElement::setWidth( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
}
// --------------------------------------------------------------------------
HTMLTableElement::HTMLTableElement() : HTMLElement()
{
}
HTMLTableElement::HTMLTableElement(const HTMLTableElement &other) : HTMLElement(other)
{
}
HTMLTableElement::HTMLTableElement(HTMLTableElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableElement &HTMLTableElement::operator = (const Node &other)
{
assignOther( other, ID_TABLE );
return *this;
}
HTMLTableElement &HTMLTableElement::operator = (const HTMLTableElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableElement::~HTMLTableElement()
{
}
HTMLTableCaptionElement HTMLTableElement::caption() const
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->caption();
}
void HTMLTableElement::setCaption( const HTMLTableCaptionElement &_caption )
{
if(impl)
((HTMLTableElementImpl *)impl)
->setCaption( ((HTMLTableCaptionElementImpl *)_caption.impl) );
}
HTMLTableSectionElement HTMLTableElement::tHead() const
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->tHead();
}
void HTMLTableElement::setTHead( const HTMLTableSectionElement &_tHead )
{
if(impl)
((HTMLTableElementImpl *)impl)
->setTHead( ((HTMLTableSectionElementImpl *)_tHead.impl) );
}
HTMLTableSectionElement HTMLTableElement::tFoot() const
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->tFoot();
}
void HTMLTableElement::setTFoot( const HTMLTableSectionElement &_tFoot )
{
if(impl)
((HTMLTableElementImpl *)impl)
->setTFoot( ((HTMLTableSectionElementImpl *)_tFoot.impl) );
}
HTMLCollection HTMLTableElement::rows() const
{
if(!impl) return HTMLCollection();
return HTMLCollection(impl, HTMLCollectionImpl::TABLE_ROWS);
}
HTMLCollection HTMLTableElement::tBodies() const
{
if(!impl) return HTMLCollection();
return HTMLCollection(impl, HTMLCollectionImpl::TABLE_TBODIES);
}
DOMString HTMLTableElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLTableElement::bgColor() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
}
void HTMLTableElement::setBgColor( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
}
DOMString HTMLTableElement::border() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_BORDER);
}
void HTMLTableElement::setBorder( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BORDER, value);
}
DOMString HTMLTableElement::cellPadding() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CELLPADDING);
}
void HTMLTableElement::setCellPadding( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CELLPADDING, value);
}
DOMString HTMLTableElement::cellSpacing() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CELLSPACING);
}
void HTMLTableElement::setCellSpacing( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CELLSPACING, value);
}
DOMString HTMLTableElement::frame() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_FRAME);
}
void HTMLTableElement::setFrame( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_FRAME, value);
}
DOMString HTMLTableElement::rules() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_RULES);
}
void HTMLTableElement::setRules( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_RULES, value);
}
DOMString HTMLTableElement::summary() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_SUMMARY);
}
void HTMLTableElement::setSummary( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_SUMMARY, value);
}
DOMString HTMLTableElement::width() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
}
void HTMLTableElement::setWidth( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
}
HTMLElement HTMLTableElement::createTHead( )
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->createTHead( );
}
void HTMLTableElement::deleteTHead( )
{
if(impl)
((HTMLTableElementImpl *)impl)->deleteTHead( );
}
HTMLElement HTMLTableElement::createTFoot( )
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->createTFoot( );
}
void HTMLTableElement::deleteTFoot( )
{
if(impl)
((HTMLTableElementImpl *)impl)->deleteTFoot( );
}
HTMLElement HTMLTableElement::createCaption( )
{
if(!impl) return 0;
return ((HTMLTableElementImpl *)impl)->createCaption( );
}
void HTMLTableElement::deleteCaption( )
{
if(impl)
((HTMLTableElementImpl *)impl)->deleteCaption( );
}
HTMLElement HTMLTableElement::insertRow( long index )
{
if(!impl) return 0;
int exceptioncode = 0;
HTMLElementImpl* ret = ((HTMLTableElementImpl *)impl)->insertRow( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
return ret;
}
void HTMLTableElement::deleteRow( long index )
{
int exceptioncode = 0;
if(impl)
((HTMLTableElementImpl *)impl)->deleteRow( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
}
// --------------------------------------------------------------------------
HTMLTableRowElement::HTMLTableRowElement() : HTMLElement()
{
}
HTMLTableRowElement::HTMLTableRowElement(const HTMLTableRowElement &other) : HTMLElement(other)
{
}
HTMLTableRowElement::HTMLTableRowElement(HTMLTableRowElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableRowElement &HTMLTableRowElement::operator = (const Node &other)
{
assignOther( other, ID_TR );
return *this;
}
HTMLTableRowElement &HTMLTableRowElement::operator = (const HTMLTableRowElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableRowElement::~HTMLTableRowElement()
{
}
long HTMLTableRowElement::rowIndex() const
{
if(!impl) return 0;
return ((HTMLTableRowElementImpl *)impl)->rowIndex();
}
void HTMLTableRowElement::setRowIndex( long /*_rowIndex*/ )
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
long HTMLTableRowElement::sectionRowIndex() const
{
if(!impl) return 0;
return ((HTMLTableRowElementImpl *)impl)->sectionRowIndex();
}
void HTMLTableRowElement::setSectionRowIndex( long /*_sectionRowIndex*/ )
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
HTMLCollection HTMLTableRowElement::cells() const
{
if(!impl) return HTMLCollection();
return HTMLCollection(impl, HTMLCollectionImpl::TR_CELLS);
}
void HTMLTableRowElement::setCells( const HTMLCollection & /*_cells*/ )
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
DOMString HTMLTableRowElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableRowElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLTableRowElement::bgColor() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
}
void HTMLTableRowElement::setBgColor( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
}
DOMString HTMLTableRowElement::ch() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
}
void HTMLTableRowElement::setCh( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
}
DOMString HTMLTableRowElement::chOff() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
}
void HTMLTableRowElement::setChOff( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
}
DOMString HTMLTableRowElement::vAlign() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
}
void HTMLTableRowElement::setVAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
}
HTMLElement HTMLTableRowElement::insertCell( long index )
{
if(!impl) return 0;
int exceptioncode = 0;
HTMLElementImpl* ret = ((HTMLTableRowElementImpl *)impl)->insertCell( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
return ret;
}
void HTMLTableRowElement::deleteCell( long index )
{
int exceptioncode = 0;
if(impl)
((HTMLTableRowElementImpl *)impl)->deleteCell( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
}
// --------------------------------------------------------------------------
HTMLTableSectionElement::HTMLTableSectionElement() : HTMLElement()
{
}
HTMLTableSectionElement::HTMLTableSectionElement(const HTMLTableSectionElement &other) : HTMLElement(other)
{
}
HTMLTableSectionElement::HTMLTableSectionElement(HTMLTableSectionElementImpl *impl) : HTMLElement(impl)
{
}
HTMLTableSectionElement &HTMLTableSectionElement::operator = (const Node &other)
{
if(other.elementId() != ID_TBODY &&
other.elementId() != ID_THEAD &&
other.elementId() != ID_TFOOT )
{
if ( impl ) impl->deref();
impl = 0;
} else {
Node::operator = (other);
}
return *this;
}
HTMLTableSectionElement &HTMLTableSectionElement::operator = (const HTMLTableSectionElement &other)
{
HTMLElement::operator = (other);
return *this;
}
HTMLTableSectionElement::~HTMLTableSectionElement()
{
}
DOMString HTMLTableSectionElement::align() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
}
void HTMLTableSectionElement::setAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
}
DOMString HTMLTableSectionElement::ch() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
}
void HTMLTableSectionElement::setCh( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
}
DOMString HTMLTableSectionElement::chOff() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
}
void HTMLTableSectionElement::setChOff( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
}
DOMString HTMLTableSectionElement::vAlign() const
{
if(!impl) return DOMString();
return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
}
void HTMLTableSectionElement::setVAlign( const DOMString &value )
{
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
}
HTMLCollection HTMLTableSectionElement::rows() const
{
if(!impl) return HTMLCollection();
return HTMLCollection(impl, HTMLCollectionImpl::TSECTION_ROWS);
}
HTMLElement HTMLTableSectionElement::insertRow( long index )
{
if(!impl) return 0;
int exceptioncode = 0;
HTMLElementImpl* ret = ((HTMLTableSectionElementImpl *)impl)->insertRow( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
return ret;
}
void HTMLTableSectionElement::deleteRow( long index )
{
int exceptioncode = 0;
if(impl)
((HTMLTableSectionElementImpl *)impl)->deleteRow( index, exceptioncode );
if (exceptioncode)
throw DOMException(exceptioncode);
}
DOM::HTMLTableRowElement::setCells
void setCells(const HTMLCollection &)
see cells
Definition: html_table.cpp:683
DOM::HTMLTableElement::tBodies
HTMLCollection tBodies() const
Returns a collection of the table bodies (including implicit ones).
Definition: html_table.cpp:465
DOM::HTMLTableElement::setBgColor
void setBgColor(const DOMString &)
see bgColor
Definition: html_table.cpp:488
DOM::HTMLTableCellElement::cellIndex
long cellIndex() const
The index of this cell in the row.
Definition: html_table.cpp:110
DOM::HTMLTableSectionElement::setChOff
void setChOff(const DOMString &)
see chOff
Definition: html_table.cpp:828
DOM::HTMLTableRowElement::setCh
void setCh(const DOMString &)
see ch
Definition: html_table.cpp:716
DOM::HTMLTableElement::setCellSpacing
void setCellSpacing(const DOMString &)
see cellSpacing
Definition: html_table.cpp:521
DOM::HTMLTableSectionElement::setVAlign
void setVAlign(const DOMString &)
see vAlign
Definition: html_table.cpp:839
DOM::HTMLTableRowElement::setVAlign
void setVAlign(const DOMString &)
see vAlign
Definition: html_table.cpp:738
DOM::Node
The Node interface is the primary datatype for the entire Document Object Model.
Definition: dom_node.h:274
DOM::HTMLTableCaptionElement
Table caption See the CAPTION element definition in HTML 4.0.
Definition: html_table.h:47
DOM::HTMLTableCellElement::setAxis
void setAxis(const DOMString &)
see axis
Definition: html_table.cpp:149
DOM::HTMLTableElement::deleteTFoot
void deleteTFoot()
Delete the footer from the table, if one exists.
Definition: html_table.cpp:588
DOM::HTMLTableSectionElement::rows
HTMLCollection rows() const
The collection of rows in this table section.
Definition: html_table.cpp:844
DOM::HTMLTableRowElement::rowIndex
long rowIndex() const
The index of this row, relative to the entire table.
Definition: html_table.cpp:655
DOM::HTMLTableElement::deleteRow
void deleteRow(long index)
Delete a table row.
Definition: html_table.cpp:616
DOM::HTMLTableSectionElement
The THEAD , TFOOT , and TBODY elements.
Definition: html_table.h:895
DOM::HTMLTableCellElement::setBgColor
void setBgColor(const DOMString &)
see bgColor
Definition: html_table.cpp:160
DOM::HTMLTableElement::tHead
HTMLTableSectionElement tHead() const
Returns the table's THEAD , or null if none exists.
Definition: html_table.cpp:431
DOM::HTMLTableCellElement::noWrap
bool noWrap() const
Suppress word wrapping.
Definition: html_table.cpp:223
DOM::HTMLTableCellElement
The object used to represent the TH and TD elements.
Definition: html_table.h:91
DOM::HTMLTableSectionElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:806
DOM::HTMLTableCellElement::setNoWrap
void setNoWrap(bool)
see noWrap
Definition: html_table.cpp:229
DOM::HTMLTableCellElement::abbr
DOMString abbr() const
Abbreviation for header cells.
Definition: html_table.cpp:121
DOM::HTMLTableElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:477
DOM::HTMLTableCellElement::rowSpan
long rowSpan() const
Number of rows spanned by cell.
Definition: html_table.cpp:235
DOM::HTMLTableElement::rows
HTMLCollection rows() const
Returns a collection of all the rows in the table, including all in THEAD , TFOOT ...
Definition: html_table.cpp:459
DOM::HTMLTableRowElement::ch
DOMString ch() const
Alignment character for cells in a column.
Definition: html_table.cpp:710
DOM::HTMLTableColElement::setSpan
void setSpan(long)
see span
Definition: html_table.cpp:358
DOM::HTMLTableElement::setRules
void setRules(const DOMString &)
see rules
Definition: html_table.cpp:543
DOM::HTMLTableRowElement::setSectionRowIndex
void setSectionRowIndex(long)
see sectionRowIndex
Definition: html_table.cpp:672
DOM::HTMLTableRowElement::sectionRowIndex
long sectionRowIndex() const
The index of this row, relative to the current section ( THEAD , TFOOT , or TBODY )...
Definition: html_table.cpp:666
DOM::HTMLTableCellElement::width
DOMString width() const
Cell width.
Definition: html_table.cpp:271
DOM::HTMLTableElement::setTHead
void setTHead(const HTMLTableSectionElement &)
see tHead
Definition: html_table.cpp:437
DOM::HTMLTableColElement::ch
DOMString ch() const
Alignment character for cells in a column.
Definition: html_table.cpp:330
DOM::HTMLTableCellElement::setScope
void setScope(const DOMString &)
see scope
Definition: html_table.cpp:255
DOM::HTMLTableSectionElement::chOff
DOMString chOff() const
Offset of alignment character.
Definition: html_table.cpp:822
DOM::HTMLTableRowElement::cells
HTMLCollection cells() const
The collection of cells in this row.
Definition: html_table.cpp:677
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:57
DOM::HTMLTableElement::bgColor
DOMString bgColor() const
Cell background color.
Definition: html_table.cpp:482
DOM::HTMLTableRowElement::vAlign
DOMString vAlign() const
Vertical alignment of data within cells of this row.
Definition: html_table.cpp:732
DOM::HTMLTableCellElement::setCh
void setCh(const DOMString &)
see ch
Definition: html_table.cpp:171
DOM::HTMLTableColElement
Regroups the COL and COLGROUP elements.
Definition: html_table.h:322
DOM::HTMLTableCellElement::axis
DOMString axis() const
Names group of related headers.
Definition: html_table.cpp:143
DOM::HTMLTableCellElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:138
DOM::HTMLCollection
An HTMLCollection is a list of nodes.
Definition: html_misc.h:126
DOM::HTMLTableRowElement::setChOff
void setChOff(const DOMString &)
see chOff
Definition: html_table.cpp:727
DOM::HTMLTableRowElement::insertCell
HTMLElement insertCell(long index)
Insert an empty TD cell into this row.
Definition: html_table.cpp:743
DOM::HTMLTableCaptionElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:68
DOM::HTMLTableCellElement::colSpan
long colSpan() const
Number of columns spanned by cell.
Definition: html_table.cpp:187
DOM::HTMLTableCellElement::setVAlign
void setVAlign(const DOMString &)
see vAlign
Definition: html_table.cpp:266
DOM::HTMLTableElement::deleteCaption
void deleteCaption()
Delete the table caption, if one exists.
Definition: html_table.cpp:600
DOM::HTMLTableSectionElement::ch
DOMString ch() const
Alignment character for cells in a column.
Definition: html_table.cpp:811
DOM::HTMLTableElement::frame
DOMString frame() const
Specifies which external table borders to render.
Definition: html_table.cpp:526
DOM::HTMLTableElement::width
DOMString width() const
Specifies the desired table width.
Definition: html_table.cpp:559
DOM::HTMLTableColElement::chOff
DOMString chOff() const
Offset of alignment character.
Definition: html_table.cpp:341
DOM::HTMLTableElement::align
DOMString align() const
Specifies the table's position with respect to the rest of the document.
Definition: html_table.cpp:471
DOM::HTMLTableElement::summary
DOMString summary() const
Supplementary description about the purpose or structure of a table.
Definition: html_table.cpp:548
DOM::HTMLTableElement::setCellPadding
void setCellPadding(const DOMString &)
see cellPadding
Definition: html_table.cpp:510
DOM::HTMLTableColElement::setWidth
void setWidth(const DOMString &)
see width
Definition: html_table.cpp:383
DOM::HTMLTableSectionElement::deleteRow
void deleteRow(long index)
Delete a row from this section.
Definition: html_table.cpp:860
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
DOM::HTMLTableCellElement::setHeaders
void setHeaders(const DOMString &)
see headers
Definition: html_table.cpp:207
DOM::HTMLTableRowElement::bgColor
DOMString bgColor() const
Background color for rows.
Definition: html_table.cpp:699
DOM::HTMLTableCellElement::setWidth
void setWidth(const DOMString &)
see width
Definition: html_table.cpp:277
DOM::HTMLTableRowElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:694
DOM::HTMLTableColElement::align
DOMString align() const
Horizontal alignment of cell data in column.
Definition: html_table.cpp:319
DOM::HTMLTableSectionElement::insertRow
HTMLElement insertRow(long index)
Insert a row into this section.
Definition: html_table.cpp:850
DOM::HTMLTableSectionElement::vAlign
DOMString vAlign() const
Vertical alignment of data in cells.
Definition: html_table.cpp:833
DOM::HTMLTableElement::setCaption
void setCaption(const HTMLTableCaptionElement &)
see caption
Definition: html_table.cpp:424
DOM::HTMLTableElement::insertRow
HTMLElement insertRow(long index)
Insert a new empty row in the table.
Definition: html_table.cpp:606
DOM::HTMLTableElement::createTHead
HTMLElement createTHead()
Create a table header row or return an existing one.
Definition: html_table.cpp:570
DOM::HTMLTableCellElement::chOff
DOMString chOff() const
Offset of alignment character.
Definition: html_table.cpp:176
DOM::HTMLTableCellElement::ch
DOMString ch() const
Alignment character for cells in a column.
Definition: html_table.cpp:165
DOM::HTMLTableSectionElement::setCh
void setCh(const DOMString &)
see ch
Definition: html_table.cpp:817
DOM::HTMLTableColElement::setAlign
void setAlign(const DOMString &)
see align
Definition: html_table.cpp:325
DOM::HTMLTableElement::setFrame
void setFrame(const DOMString &)
see frame
Definition: html_table.cpp:532
DOM::HTMLTableElement::setTFoot
void setTFoot(const HTMLTableSectionElement &)
see tFoot
Definition: html_table.cpp:451
DOM::HTMLTableElement::setBorder
void setBorder(const DOMString &)
see border
Definition: html_table.cpp:499
DOM::HTMLTableCaptionElement::align
DOMString align() const
Caption alignment with respect to the table.
Definition: html_table.cpp:62
DOM::HTMLTableCellElement::vAlign
DOMString vAlign() const
Vertical alignment of data in cell.
Definition: html_table.cpp:260
DOM::HTMLTableElement::border
DOMString border() const
The width of the border around the table.
Definition: html_table.cpp:493
DOM::HTMLTableCellElement::setChOff
void setChOff(const DOMString &)
see chOff
Definition: html_table.cpp:182
DOM::HTMLTableElement::tFoot
HTMLTableSectionElement tFoot() const
Returns the table's TFOOT , or null if none exists.
Definition: html_table.cpp:445
DOM::HTMLTableElement::rules
DOMString rules() const
Specifies which internal table borders to render.
Definition: html_table.cpp:537
DOM::HTMLTableCellElement::align
DOMString align() const
Horizontal alignment of data in cell.
Definition: html_table.cpp:132
DOM::HTMLTableRowElement
A row in a table.
Definition: html_table.h:725
DOM::HTMLTableColElement::span
long span() const
Indicates the number of columns in a group or affected by a grouping.
Definition: html_table.cpp:352
DOM::HTMLTableColElement::width
DOMString width() const
Default column width.
Definition: html_table.cpp:377
DOM::HTMLTableRowElement::setRowIndex
void setRowIndex(long)
see rowIndex
Definition: html_table.cpp:661
DOM::HTMLTableRowElement::setBgColor
void setBgColor(const DOMString &)
see bgColor
Definition: html_table.cpp:705
DOM::HTMLTableElement::createTFoot
HTMLElement createTFoot()
Create a table footer row or return an existing one.
Definition: html_table.cpp:582
DOM::HTMLTableCellElement::bgColor
DOMString bgColor() const
Cell background color.
Definition: html_table.cpp:154
DOM::HTMLTableCellElement::setCellIndex
void setCellIndex(long)
see cellIndex
Definition: html_table.cpp:116
DOM::HTMLTableColElement::vAlign
DOMString vAlign() const
Vertical alignment of cell data in column.
Definition: html_table.cpp:366
DOM::HTMLTableCellElement::setHeight
void setHeight(const DOMString &)
see height
Definition: html_table.cpp:218
DOM::HTMLTableCellElement::headers
DOMString headers() const
List of id attribute values for header cells.
Definition: html_table.cpp:201
DOM::HTMLTableCellElement::setAbbr
void setAbbr(const DOMString &)
see abbr
Definition: html_table.cpp:127
DOM::HTMLTableElement::deleteTHead
void deleteTHead()
Delete the header from the table, if one exists.
Definition: html_table.cpp:576
DOM::HTMLTableElement::setWidth
void setWidth(const DOMString &)
see width
Definition: html_table.cpp:565
DOM::HTMLTableColElement::setChOff
void setChOff(const DOMString &)
see chOff
Definition: html_table.cpp:347
DOM::HTMLTableCellElement::setColSpan
void setColSpan(long)
see colSpan
Definition: html_table.cpp:193
DOM::HTMLTableElement::createCaption
HTMLElement createCaption()
Create a new table caption object or return an existing one.
Definition: html_table.cpp:594
DOM::HTMLTableRowElement::deleteCell
void deleteCell(long index)
Delete a cell from the current row.
Definition: html_table.cpp:753
DOM::HTMLTableElement::cellSpacing
DOMString cellSpacing() const
Specifies the horizontal and vertical separation between cells.
Definition: html_table.cpp:515
DOM::HTMLTableCellElement::setRowSpan
void setRowSpan(long)
see rowSpan
Definition: html_table.cpp:241
DOM::HTMLTableCellElement::scope
DOMString scope() const
Scope covered by header cells.
Definition: html_table.cpp:249
DOM::HTMLTableRowElement::align
DOMString align() const
Horizontal alignment of data within cells of this row.
Definition: html_table.cpp:688
DOM::HTMLTableColElement::setCh
void setCh(const DOMString &)
see ch
Definition: html_table.cpp:336
DOM::HTMLTableElement
The create* and delete* methods on the table allow authors to construct and modify tables...
Definition: html_table.h:441
DOM::HTMLTableSectionElement::align
DOMString align() const
Horizontal alignment of data in cells.
Definition: html_table.cpp:800
DOM::HTMLTableCellElement::height
DOMString height() const
Cell height.
Definition: html_table.cpp:212
DOM::HTMLTableElement::cellPadding
DOMString cellPadding() const
Specifies the horizontal and vertical space between cell content and cell borders.
Definition: html_table.cpp:504
DOM::HTMLElement
All HTML element interfaces derive from this class.
Definition: html_element.h:69
DOM::HTMLTableElement::setSummary
void setSummary(const DOMString &)
see summary
Definition: html_table.cpp:554
DOM::HTMLTableColElement::setVAlign
void setVAlign(const DOMString &)
see vAlign
Definition: html_table.cpp:372
DOM::HTMLTableElement::caption
HTMLTableCaptionElement caption() const
Returns the table's CAPTION , or void if none exists.
Definition: html_table.cpp:418
DOM::HTMLTableRowElement::chOff
DOMString chOff() const
Offset of alignment character.
Definition: html_table.cpp:721

KDE Home | KDE Accessibility Home | Description of Access Keys