From dfe289850f068f19ba4a83ab4e7e22a7e09c13c9 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sat, 26 Jan 2013 13:17:21 -0600 Subject: Rename a number of libraries and executables to avoid conflicts with KDE4 --- tdehtml/html/html_tableimpl.h | 329 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 tdehtml/html/html_tableimpl.h (limited to 'tdehtml/html/html_tableimpl.h') diff --git a/tdehtml/html/html_tableimpl.h b/tdehtml/html/html_tableimpl.h new file mode 100644 index 000000000..76d81ce50 --- /dev/null +++ b/tdehtml/html/html_tableimpl.h @@ -0,0 +1,329 @@ +/* + * 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 + -- cgit v1.2.1