You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
525 lines
16 KiB
525 lines
16 KiB
/*
|
|
* This file is part of the DOM implementation for KDE.
|
|
*
|
|
* Copyright (C) 1997 Martin Jones (mjones@kde.org)
|
|
* (C) 1997 Torben Weis (weis@kde.org)
|
|
* (C) 1998 Waldo Bastian (bastian@kde.org)
|
|
* (C) 1999-2003 Lars Knoll (knoll@kde.org)
|
|
* (C) 1999 Antti Koivisto (koivisto@kde.org)
|
|
* (C) 2003 Apple Computer, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public License
|
|
* along with this library; see the file COPYING.LIB. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*
|
|
*/
|
|
#ifndef RENDER_TABLE_H
|
|
#define RENDER_TABLE_H
|
|
|
|
#include <tqcolor.h>
|
|
#include <tqptrvector.h>
|
|
|
|
#include "rendering/render_box.h"
|
|
#include "rendering/render_block.h"
|
|
#include "rendering/render_style.h"
|
|
|
|
#include "misc/khtmllayout.h"
|
|
|
|
namespace DOM {
|
|
class DOMString;
|
|
}
|
|
|
|
namespace khtml {
|
|
|
|
class RenderTable;
|
|
class RenderTableSection;
|
|
class RenderTableRow;
|
|
class RenderTableCell;
|
|
class RenderTableCol;
|
|
class TableLayout;
|
|
|
|
class RenderTable : public RenderBlock
|
|
{
|
|
public:
|
|
|
|
RenderTable(DOM::NodeImpl* node);
|
|
~RenderTable();
|
|
|
|
virtual const char *renderName() const { return "RenderTable"; }
|
|
|
|
virtual void setStyle(RenderStyle *style);
|
|
|
|
virtual bool isTable() const { return true; }
|
|
|
|
int getColumnPos(int col) const
|
|
{ return columnPos[col]; }
|
|
|
|
int borderHSpacing() const { return hspacing; }
|
|
int borderVSpacing() const { return vspacing; }
|
|
|
|
bool collapseBorders() const { return style()->borderCollapse(); }
|
|
int borderLeft() const;
|
|
int borderRight() const;
|
|
int borderTop() const;
|
|
int borderBottom() const;
|
|
int paddingLeft() const { return collapseBorders() ? 0 : RenderBlock::paddingLeft(); }
|
|
int paddingRight() const { return collapseBorders() ? 0 : RenderBlock::paddingRight(); }
|
|
int paddingTop() const { return collapseBorders() ? 0 : RenderBlock::paddingTop(); }
|
|
int paddingBottom() const { return collapseBorders() ? 0 : RenderBlock::paddingBottom(); }
|
|
|
|
const TQColor &bgColor() const { return style()->backgroundColor(); }
|
|
|
|
uint cellPadding() const { return padding; }
|
|
void setCellPadding( uint p ) { padding = p; }
|
|
|
|
// overrides
|
|
virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0);
|
|
virtual void paint( PaintInfo&, int tx, int ty);
|
|
virtual void paintBoxDecorations(PaintInfo&, int _tx, int _ty);
|
|
virtual void layout();
|
|
virtual void calcMinMaxWidth();
|
|
virtual void close();
|
|
|
|
virtual short lineHeight(bool b) const;
|
|
virtual short baselinePosition(bool b) const;
|
|
|
|
virtual void setCellWidths( );
|
|
|
|
virtual void calcWidth();
|
|
|
|
virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty,
|
|
DOM::NodeImpl*& node, int & offset,
|
|
SelPointState & );
|
|
|
|
#ifdef ENABLE_DUMP
|
|
virtual void dump(TQTextStream &stream, const TQString &ind) const;
|
|
#endif
|
|
struct ColumnStruct {
|
|
enum {
|
|
WidthUndefined = 0xffff
|
|
};
|
|
ColumnStruct() {
|
|
span = 1;
|
|
width = WidthUndefined;
|
|
}
|
|
ushort span;
|
|
ushort width; // the calculated position of the column
|
|
};
|
|
|
|
TQMemArray<int> columnPos;
|
|
TQMemArray<ColumnStruct> columns;
|
|
|
|
void splitColumn( int pos, int firstSpan );
|
|
void appendColumn( int span );
|
|
int numEffCols() const { return columns.size(); }
|
|
int spanOfEffCol( int effCol ) const { return columns[effCol].span; }
|
|
int colToEffCol( int col ) const {
|
|
int c = 0;
|
|
int i = 0;
|
|
while ( c < col && i < (int)columns.size() ) {
|
|
c += columns[i].span;
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
int effColToCol( int effCol ) const {
|
|
int c = 0;
|
|
for ( int i = 0; i < effCol; i++ )
|
|
c += columns[i].span;
|
|
return c;
|
|
}
|
|
|
|
int bordersPaddingAndSpacing() const {
|
|
return borderLeft() + borderRight() +
|
|
(collapseBorders() ? 0 : (paddingLeft() + paddingRight() + (numEffCols()+1) * borderHSpacing()));
|
|
}
|
|
|
|
RenderTableCol *colElement( int col );
|
|
|
|
void setNeedSectionRecalc() { needSectionRecalc = true; }
|
|
|
|
virtual RenderObject* removeChildNode(RenderObject* child);
|
|
|
|
RenderTableSection* sectionAbove(const RenderTableSection*, bool skipEmptySections = false) const;
|
|
RenderTableSection* sectionBelow(const RenderTableSection*, bool skipEmptySections = false) const;
|
|
|
|
RenderTableCell* cellAbove(const RenderTableCell* cell) const;
|
|
RenderTableCell* cellBelow(const RenderTableCell* cell) const;
|
|
RenderTableCell* cellLeft(const RenderTableCell* cell) const;
|
|
RenderTableCell* cellRight(const RenderTableCell* cell) const;
|
|
|
|
CollapsedBorderValue* currentBorderStyle() { return m_currentBorder; }
|
|
|
|
RenderTableSection *firstBodySection() const { return firstBody; }
|
|
RenderFlow* caption() const { return tCaption; }
|
|
|
|
protected:
|
|
|
|
void recalcSections();
|
|
|
|
friend class AutoTableLayout;
|
|
friend class FixedTableLayout;
|
|
|
|
RenderFlow *tCaption;
|
|
RenderTableSection *head;
|
|
RenderTableSection *foot;
|
|
RenderTableSection *firstBody;
|
|
|
|
TableLayout *tableLayout;
|
|
|
|
CollapsedBorderValue* m_currentBorder;
|
|
|
|
bool has_col_elems : 1;
|
|
uint needSectionRecalc : 1;
|
|
uint padding : 22;
|
|
|
|
ushort hspacing;
|
|
ushort vspacing;
|
|
|
|
friend class TableSectionIterator;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
class RenderTableSection : public RenderBox
|
|
{
|
|
public:
|
|
RenderTableSection(DOM::NodeImpl* node);
|
|
~RenderTableSection();
|
|
virtual void detach();
|
|
|
|
virtual void setStyle(RenderStyle *style);
|
|
|
|
virtual const char *renderName() const { return "RenderTableSection"; }
|
|
|
|
// overrides
|
|
virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0);
|
|
virtual bool isTableSection() const { return true; }
|
|
|
|
virtual short lineHeight(bool) const { return 0; }
|
|
virtual void position(InlineBox*, int, int, bool) {}
|
|
|
|
virtual short width() const;
|
|
|
|
virtual FindSelectionResult checkSelectionPoint( int _x, int _y, int _tx, int _ty,
|
|
DOM::NodeImpl*& node, int & offset,
|
|
SelPointState & );
|
|
|
|
#ifdef ENABLE_DUMP
|
|
virtual void dump(TQTextStream &stream, const TQString &ind) const;
|
|
#endif
|
|
|
|
void addCell( RenderTableCell *cell, RenderTableRow *row );
|
|
|
|
void setCellWidths();
|
|
void calcRowHeight();
|
|
int layoutRows( int height );
|
|
|
|
RenderTable *table() const { return static_cast<RenderTable *>(parent()); }
|
|
|
|
typedef TQMemArray<RenderTableCell *> Row;
|
|
struct RowStruct {
|
|
Row *row;
|
|
RenderTableRow* rowRenderer;
|
|
int baseLine;
|
|
Length height;
|
|
bool needFlex;
|
|
};
|
|
|
|
RenderTableCell *&cellAt( int row, int col ) {
|
|
return (*(grid[row].row))[col];
|
|
}
|
|
RenderTableCell *cellAt( int row, int col ) const {
|
|
return (*(grid[row].row))[col];
|
|
}
|
|
|
|
virtual int lowestPosition(bool includeOverflowInterior, bool includeSelf) const;
|
|
virtual int rightmostPosition(bool includeOverflowInterior, bool includeSelf) const;
|
|
virtual int leftmostPosition(bool includeOverflowInterior, bool includeSelf) const;
|
|
virtual int highestPosition(bool includeOverflowInterior, bool includeSelf) const;
|
|
|
|
int borderLeft() const { return table()->collapseBorders() ? 0 : RenderBox::borderLeft(); }
|
|
int borderRight() const { return table()->collapseBorders() ? 0 : RenderBox::borderRight(); }
|
|
int borderTop() const { return table()->collapseBorders() ? 0 : RenderBox::borderTop(); }
|
|
int borderBottom() const { return table()->collapseBorders() ? 0 : RenderBox::borderBottom(); }
|
|
|
|
virtual void paint( PaintInfo& i, int tx, int ty);
|
|
|
|
int numRows() const { return grid.size(); }
|
|
int getBaseline(int row) {return grid[row].baseLine;}
|
|
|
|
void setNeedCellRecalc() {
|
|
needCellRecalc = true;
|
|
table()->setNeedSectionRecalc();
|
|
}
|
|
|
|
virtual RenderObject* removeChildNode(RenderObject* child);
|
|
|
|
virtual bool canClear(RenderObject *child, PageBreakLevel level);
|
|
void addSpaceAt(int pos, int dy);
|
|
|
|
virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside);
|
|
|
|
// this gets a cell grid data structure. changing the number of
|
|
// columns is done by the table
|
|
TQMemArray<RowStruct> grid;
|
|
TQMemArray<int> rowPos;
|
|
|
|
signed short cRow;
|
|
ushort cCol;
|
|
bool needCellRecalc;
|
|
|
|
void recalcCells();
|
|
protected:
|
|
void ensureRows( int numRows );
|
|
void clearGrid();
|
|
bool emptyRow(int rowNum);
|
|
bool flexCellChildren(RenderObject* p) const;
|
|
|
|
|
|
friend class TableSectionIterator;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
class RenderTableRow : public RenderContainer
|
|
{
|
|
public:
|
|
RenderTableRow(DOM::NodeImpl* node);
|
|
|
|
virtual void detach();
|
|
|
|
virtual void setStyle( RenderStyle* );
|
|
virtual const char *renderName() const { return "RenderTableRow"; }
|
|
virtual bool isTableRow() const { return true; }
|
|
virtual void addChild(RenderObject *child, RenderObject *beforeChild = 0);
|
|
|
|
virtual short offsetWidth() const;
|
|
virtual int offsetHeight() const;
|
|
virtual int offsetLeft() const;
|
|
virtual int offsetTop() const;
|
|
|
|
virtual short lineHeight( bool ) const { return 0; }
|
|
virtual void position(InlineBox*, int, int, bool) {}
|
|
|
|
virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty, HitTestAction action, bool inside);
|
|
|
|
virtual void layout();
|
|
|
|
virtual RenderObject* removeChildNode(RenderObject* child);
|
|
|
|
// The only time rows get a layer is when they have transparency.
|
|
virtual bool requiresLayer() const { return /* style()->opacity() < 1.0f; */ false ; }
|
|
virtual void paint(PaintInfo& i, int tx, int ty);
|
|
|
|
void paintRow( PaintInfo& i, int tx, int ty, int w, int h);
|
|
|
|
RenderTable *table() const { return static_cast<RenderTable *>(parent()->parent()); }
|
|
RenderTableSection *section() const { return static_cast<RenderTableSection *>(parent()); }
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
class RenderTableCell : public RenderBlock
|
|
{
|
|
public:
|
|
RenderTableCell(DOM::NodeImpl* node);
|
|
|
|
virtual void layout();
|
|
virtual void detach();
|
|
|
|
virtual const char *renderName() const { return "RenderTableCell"; }
|
|
virtual bool isTableCell() const { return true; }
|
|
|
|
// ### FIX these two...
|
|
long cellIndex() const { return 0; }
|
|
void setCellIndex( long ) { }
|
|
|
|
unsigned short colSpan() const { return cSpan; }
|
|
void setColSpan( unsigned short c ) { cSpan = c; }
|
|
|
|
unsigned short rowSpan() const { return rSpan; }
|
|
void setRowSpan( unsigned short r ) { rSpan = r; }
|
|
|
|
int col() const { return _col; }
|
|
void setCol(int col) { _col = col; }
|
|
int row() const { return _row; }
|
|
void setRow(int r) { _row = r; }
|
|
|
|
Length styleOrColWidth();
|
|
|
|
// overrides
|
|
virtual void calcMinMaxWidth();
|
|
virtual void calcWidth();
|
|
virtual void setWidth( int width );
|
|
virtual void setStyle( RenderStyle *style );
|
|
virtual bool requiresLayer() const;
|
|
|
|
int borderLeft() const;
|
|
int borderRight() const;
|
|
int borderTop() const;
|
|
int borderBottom() const;
|
|
|
|
CollapsedBorderValue collapsedLeftBorder() const;
|
|
CollapsedBorderValue collapsedRightBorder() const;
|
|
CollapsedBorderValue collapsedTopBorder() const;
|
|
CollapsedBorderValue collapsedBottomBorder() const;
|
|
virtual void collectBorders(TQValueList<CollapsedBorderValue>& borderStyles);
|
|
|
|
virtual void updateFromElement();
|
|
|
|
void setCellTopExtra(int p) { _topExtra = p; }
|
|
void setCellBottomExtra(int p) { _bottomExtra = p; }
|
|
int cellTopExtra() const { return _topExtra; }
|
|
int cellBottomExtra() const { return _bottomExtra; }
|
|
|
|
int pageTopAfter(int x) const;
|
|
|
|
virtual void paint( PaintInfo& i, int tx, int ty);
|
|
|
|
void paintCollapsedBorder(TQPainter* p, int x, int y, int w, int h);
|
|
void paintBackgroundsBehindCell(PaintInfo& i, int _tx, int _ty, RenderObject* backgroundObject);
|
|
|
|
virtual void close();
|
|
|
|
// lie position to outside observers
|
|
virtual int yPos() const { return m_y + _topExtra; }
|
|
|
|
virtual void repaintRectangle(int x, int y, int w, int h, Priority p=NormalPriority, bool f=false);
|
|
virtual bool absolutePosition(int &xPos, int &yPos, bool f = false) const;
|
|
|
|
virtual short baselinePosition( bool = false ) const;
|
|
|
|
virtual bool nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction, bool inside);
|
|
|
|
RenderTable *table() const { return static_cast<RenderTable *>(parent()->parent()->parent()); }
|
|
RenderTableSection *section() const { return static_cast<RenderTableSection *>(parent()->parent()); }
|
|
|
|
#ifdef ENABLE_DUMP
|
|
virtual void dump(TQTextStream &stream, const TQString &ind) const;
|
|
#endif
|
|
|
|
bool widthChanged() {
|
|
bool retval = m_widthChanged;
|
|
m_widthChanged = false;
|
|
return retval;
|
|
}
|
|
|
|
int cellPercentageHeight() const
|
|
{ return m_percentageHeight; }
|
|
void setCellPercentageHeight(int h)
|
|
{ m_percentageHeight = h; }
|
|
bool hasFlexedAnonymous() const
|
|
{ return m_hasFlexedAnonymous; }
|
|
void setHasFlexedAnonymous(bool b=true)
|
|
{ m_hasFlexedAnonymous = b; }
|
|
|
|
protected:
|
|
virtual void paintBoxDecorations(PaintInfo& p, int _tx, int _ty);
|
|
virtual int borderTopExtra() const { return _topExtra; }
|
|
virtual int borderBottomExtra() const { return _bottomExtra; }
|
|
|
|
short _row;
|
|
short _col;
|
|
ushort rSpan;
|
|
ushort cSpan;
|
|
int _topExtra;
|
|
signed int _bottomExtra : 30;
|
|
bool m_widthChanged : 1;
|
|
bool m_hasFlexedAnonymous : 1;
|
|
int m_percentageHeight;
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
class RenderTableCol : public RenderContainer
|
|
{
|
|
public:
|
|
RenderTableCol(DOM::NodeImpl* node);
|
|
|
|
virtual const char *renderName() const { return "RenderTableCol"; }
|
|
|
|
virtual bool isTableCol() const { return true; }
|
|
|
|
virtual short lineHeight( bool ) const { return 0; }
|
|
virtual void position(InlineBox*, int, int, bool) {}
|
|
virtual void layout() {}
|
|
virtual bool requiresLayer() const { return false; }
|
|
|
|
virtual void updateFromElement();
|
|
|
|
#ifdef ENABLE_DUMP
|
|
virtual void dump(TQTextStream &stream, const TQString& ind) const;
|
|
#endif
|
|
|
|
int span() const { return m_span; }
|
|
void setSpan( int s ) { m_span = s; }
|
|
|
|
private:
|
|
int m_span;
|
|
};
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
/** This class provides an iterator to iterate through the sections of a
|
|
* render table in their visual order.
|
|
*
|
|
* In HTML, sections are specified in the order of THEAD, TFOOT, and TBODY.
|
|
* Visually, TBODY sections appear between THEAD and TFOOT, which this iterator
|
|
* takes into regard.
|
|
* @author Leo Savernik
|
|
* @internal
|
|
* @since 3.2
|
|
*/
|
|
class TableSectionIterator {
|
|
public:
|
|
|
|
/**
|
|
* Initializes a new iterator
|
|
* @param table table whose sections to iterate
|
|
* @param fromEnd @p true, begin with last section, @p false, begin with
|
|
* first section.
|
|
*/
|
|
TableSectionIterator(RenderTable *table, bool fromEnd = false);
|
|
|
|
/**
|
|
* Initializes a new iterator
|
|
* @param start table section to start with.
|
|
*/
|
|
TableSectionIterator(RenderTableSection *start) : sec(start) {}
|
|
|
|
/**
|
|
* Uninitialized iterator.
|
|
*/
|
|
TableSectionIterator() {}
|
|
|
|
/** Returns the current section, or @p 0 if the end has been reached.
|
|
*/
|
|
RenderTableSection *operator *() const { return sec; }
|
|
|
|
/** Moves to the next section in visual order. */
|
|
TableSectionIterator &operator ++();
|
|
|
|
/** Moves to the previous section in visual order. */
|
|
TableSectionIterator &operator --();
|
|
|
|
private:
|
|
RenderTableSection *sec;
|
|
};
|
|
|
|
}
|
|
#endif
|
|
|