/* * 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 Lars Knoll (knoll@kde.org) * (C) 1999 Antti Koivisto (koivisto@kde.org) * (C) 2006 Maksim Orlovich (maksim@kde.org) * * 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 HTML_TABLEIMPL_H #define HTML_TABLEIMPL_H #include "misc/htmltags.h" #include "html/html_elementimpl.h" namespace DOM { class DOMString; class HTMLTableElementImpl; class HTMLTableSectionElementImpl; class HTMLTableSectionElement; class HTMLTableRowElementImpl; class HTMLTableRowElement; class HTMLTableCellElementImpl; class HTMLTableCellElement; class HTMLTableColElementImpl; class HTMLTableColElement; class HTMLTableCaptionElementImpl; class HTMLTableCaptionElement; class HTMLElement; class HTMLCollection; // ------------------------------------------------------------------------- class HTMLTablePartElementImpl : public HTMLElementImpl { public: HTMLTablePartElementImpl(DocumentImpl *doc) : HTMLElementImpl(doc) { } virtual void parseAttribute(AttributeImpl *attr); }; // ------------------------------------------------------------------------- class HTMLTableSectionElementImpl : public HTMLTablePartElementImpl { public: HTMLTableSectionElementImpl(DocumentImpl *doc, ushort tagid, bool implicit); ~HTMLTableSectionElementImpl(); virtual Id id() const; HTMLElementImpl *insertRow ( long index, int& exceptioncode ); void deleteRow ( long index, int& exceptioncode ); int numRows() const; protected: ushort _id; }; // ------------------------------------------------------------------------- class HTMLTableRowElementImpl : public HTMLTablePartElementImpl { public: HTMLTableRowElementImpl(DocumentImpl *doc) : HTMLTablePartElementImpl(doc) {} virtual Id id() const; long rowIndex() const; long sectionRowIndex() const; HTMLElementImpl *insertCell ( long index, int &exceptioncode ); void deleteCell ( long index, int &exceptioncode ); protected: int ncols; }; // ------------------------------------------------------------------------- class HTMLTableCellElementImpl : public HTMLTablePartElementImpl { public: HTMLTableCellElementImpl(DocumentImpl *doc, int tagId); ~HTMLTableCellElementImpl(); long cellIndex() const; int col() const { return _col; } void setCol(int col) { _col = col; } int row() const { return _row; } void setRow(int r) { _row = r; } int colSpan() const { return cSpan; } int rowSpan() const { return rSpan; } virtual Id id() const { return _id; } virtual void parseAttribute(AttributeImpl *attr); virtual void attach(); protected: int _row; int _col; int rSpan; int cSpan; int _id; int rowHeight; bool m_solid : 1; bool m_nowrap : 1; }; // ------------------------------------------------------------------------- class HTMLTableColElementImpl : public HTMLTablePartElementImpl { public: HTMLTableColElementImpl(DocumentImpl *doc, ushort i); virtual Id id() const; void setTable(HTMLTableElementImpl *t) { table = t; } // overrides virtual void parseAttribute(AttributeImpl *attr); int span() const { return _span; } protected: // could be ID_COL or ID_COLGROUP ... The DOM is not quite clear on // this, but since both elements work quite similar, we use one // DOMElement for them... ushort _id; int _span; HTMLTableElementImpl *table; }; // ------------------------------------------------------------------------- class HTMLTableCaptionElementImpl : public HTMLTablePartElementImpl { public: HTMLTableCaptionElementImpl(DocumentImpl *doc) : HTMLTablePartElementImpl(doc) {} virtual Id id() const; virtual void parseAttribute(AttributeImpl *attr); }; // ------------------------------------------------------------------------- /* This class helps memorize pointers to child objects that may be yanked around via the DOM. It always picks the first pointer of the given type. The pointer it stores can have 3 meanings: 0 -- no child parent -- no idea about the state other -- pointer to the child */ template class ChildHolder { public: ChildHolder():ptr(0) {} ChildType* get(const ElementImpl* parent) const { if (static_cast(ptr) == parent) { //Do lookup. ptr = 0; for (NodeImpl* child = parent->firstChild(); child; child = child->nextSibling()) if (child->id() == ChildId) { ptr = static_cast(child); break; } } return static_cast(ptr); } void childAdded(ElementImpl* parent, NodeImpl* child) { if (ptr) ptr = parent; //No clue now.. else ptr = child; } void childAppended(NodeImpl* child) { if (!ptr) ptr = child; } void childRemoved(ElementImpl* parent, NodeImpl* child) { if (child == ptr) ptr = parent; //We removed what was pointing - no clue now.. //else things are unchanged. } void operator =(ChildType* child) { ptr = child; } private: mutable NodeImpl* ptr; }; // ------------------------------------------------------------------------- class HTMLTableElementImpl : public HTMLElementImpl { public: enum Rules { None = 0x00, RGroups = 0x01, CGroups = 0x02, Groups = 0x03, Rows = 0x05, Cols = 0x0a, All = 0x0f }; enum Frame { Void = 0x00, Above = 0x01, Below = 0x02, Lhs = 0x04, Rhs = 0x08, Hsides = 0x03, Vsides = 0x0c, Box = 0x0f }; HTMLTableElementImpl(DocumentImpl *doc); ~HTMLTableElementImpl(); virtual Id id() const; HTMLTableCaptionElementImpl *caption() const { return tCaption.get(this); } NodeImpl *setCaption( HTMLTableCaptionElementImpl * ); HTMLTableSectionElementImpl *tHead() const { return head.get(this); } NodeImpl *setTHead( HTMLTableSectionElementImpl * ); HTMLTableSectionElementImpl *tFoot() const { return foot.get(this); } NodeImpl *setTFoot( HTMLTableSectionElementImpl * ); NodeImpl *setTBody( HTMLTableSectionElementImpl * ); HTMLElementImpl *createTHead ( ); void deleteTHead ( ); HTMLElementImpl *createTFoot ( ); void deleteTFoot ( ); HTMLElementImpl *createCaption ( ); void deleteCaption ( ); HTMLElementImpl *insertRow ( long index, int &exceptioncode ); void deleteRow ( long index, int &exceptioncode ); // overrides virtual NodeImpl *addChild(NodeImpl *child); virtual NodeImpl *insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode ); virtual void replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode ); virtual void removeChild ( NodeImpl *oldChild, int &exceptioncode ); virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode ); virtual void parseAttribute(AttributeImpl *attr); virtual void attach(); virtual void close(); /* Tries to find the section containing row number outIndex. Returns whether it succeeded or not. negative outIndex values are interpreted as being infinite. On success, outSection, outIndex points to section, and index in that section. On failure, outSection points to the last section of the table, and index is the offset the row would have if there was an additional section. */ bool findRowSection(long inIndex, HTMLTableSectionElementImpl*& outSection, long& outIndex) const; protected: //Actual implementations of keeping things in place. void handleChildAdd ( NodeImpl *newChild ); void handleChildAppend( NodeImpl *newChild ); void handleChildRemove( NodeImpl *oldChild ); void updateFrame(); ChildHolder head; ChildHolder foot; ChildHolder firstBody; ChildHolder tCaption; HTMLTableSectionElementImpl *tFirstBody() const { return firstBody.get(this); } Frame frame : 4; Rules rules : 4; bool m_solid : 1; uint unused : 7; ushort padding : 16; friend class HTMLTableCellElementImpl; }; } //namespace #endif