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.
186 lines
6.9 KiB
186 lines
6.9 KiB
/***************************************************************************
|
|
node.h - description
|
|
-------------------
|
|
begin : Sun Apr 16 2000
|
|
copyright : (C) 2000 by Dmitry Poplavsky <pdima@mail.univ.kiev.ua>
|
|
(C) 2001-2004 Andras Mantia <amantia@kde.org>
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#ifndef NODE_H
|
|
#define NODE_H
|
|
|
|
#include <tqptrlist.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqmap.h>
|
|
#include <dom/dom_node.h>
|
|
|
|
class TQDomElement;
|
|
class TQListViewItem;
|
|
|
|
class Tag;
|
|
class Node;
|
|
class StructTreeGroup;
|
|
class XMLStructGroup;
|
|
|
|
struct GroupElement{
|
|
/*The node which contains the element */
|
|
Node *node;
|
|
/* The tag which point to the actual place in the node */
|
|
Tag *tag;
|
|
/*The parent node indicating the beginning of a structure */
|
|
Node *parentNode;
|
|
bool global;
|
|
bool deleted;
|
|
TQString type;
|
|
XMLStructGroup *group; ///<is part of this group
|
|
};
|
|
|
|
typedef TQValueList<GroupElement*> GroupElementList;
|
|
typedef TQMap<TQString, GroupElementList> GroupElementMapList;
|
|
|
|
/**
|
|
* A Node is a basic unit of a Tree. It keeps track of his parent, his left neighbour, his right neighbour
|
|
* and his first child.
|
|
* It contains some functions to navigate through the tree, but some more are located at kafkacommon.h
|
|
* (and should be moved here...)
|
|
* It also contains a pointer to a Tag object which contains informations about the contents of the Node.
|
|
* We use this class to represent the XML/SGML document as a tree ( a DOM like tree) when each Node represent
|
|
* a part of the document ( A tag, a text, ... see tag.h)
|
|
* The tree is built with the parser (see parser.h)
|
|
*/
|
|
|
|
class Node {
|
|
|
|
public:
|
|
Node( Node *parent );
|
|
~Node();
|
|
|
|
/**
|
|
* Deletes the node. Use this instead of delete node; as it checkes if there
|
|
* node was really allocated or not and avoid nasty crashes.
|
|
* @return true - if node existed and is deleted
|
|
* false - if the node did not exist
|
|
*/
|
|
static bool deleteNode(Node *node);
|
|
|
|
/**
|
|
* Copy everything from node except prev, next, child, parent, listItem, group, groupTag, which are set to Null
|
|
* The groupElementsList is cleared.
|
|
*/
|
|
void operator =(Node* node);
|
|
|
|
/** For Kafka copy/paste */
|
|
void save(TQDomElement& element) const;
|
|
bool load(TQDomElement const& element);
|
|
|
|
Node *next;
|
|
Node *prev;
|
|
Node *parent;
|
|
Node *child;
|
|
|
|
/** Returns the child if available, else the next node, else the next node of the first parent which has one, else 0L.
|
|
WARNING: it doesn't behave like DOM::Node::nextSibling() which give the next Node, or 0L if there is no next Node */
|
|
Node *nextSibling();
|
|
Node *previousSibling();
|
|
/** Returns the next node, or the parent's next, if next doesn't exists,
|
|
or the granparent's next, if parent's next doesn't exists, etc. */
|
|
Node *nextNotChild();
|
|
|
|
/** DOM like functions cf dom/dom_node.h */
|
|
TQString nodeName();
|
|
TQString nodeValue();
|
|
void setNodeValue(const TQString &value);
|
|
Node* parentNode() {return parent;}
|
|
Node* firstChild() {return child;}
|
|
Node* lastChild();
|
|
Node* DOMpreviousSibling() {return prev;}
|
|
Node* DOMnextSibling() {return next;}
|
|
/**Node* insertBefore(Node *newChild, Node *refChild);
|
|
Node* replaceChild(Node *newChild, Node *oldChild);
|
|
Node* removeChild(Node *oldChild);
|
|
Node* appendChild(Node *newChild);*/
|
|
bool hasChildNodes() {return child;}
|
|
|
|
/** Others functions. */
|
|
// check if Node has node in its child subtree (and grand-child,...)
|
|
bool hasForChild(Node *node);
|
|
void setParent(Node *nodeParent) {parent = nodeParent;}
|
|
//If Node is of type XmlTag or ScriptTag, return the corresponding XmlTagEnd if available
|
|
Node *getClosingNode();
|
|
//If Node is of type XmlTagEnd, return the corresponding XmlTag or ScriptTag if available
|
|
Node *getOpeningNode();
|
|
|
|
/** The Node link skipping Empty Nodes. */
|
|
//Returns the first next non-Empty Node
|
|
Node *nextNE();
|
|
//Returns the first prev non-Empty Node
|
|
Node *prevNE();
|
|
//Returns the first non-Empty child
|
|
Node *firstChildNE();
|
|
//Returns the last non-Empty child
|
|
Node *lastChildNE();
|
|
|
|
/**
|
|
* The main problem manipulating the default links prev/next/parent/child is that we often want
|
|
* to manipulate only the "significant" Nodes e.g. XmlTag, Text, ScriptNode, like in a DOM::Node tree.
|
|
* These functions, prefixed with "S" which stands for "simplified" or "significant", will only return
|
|
* and manipulate XmlTag, Text and ScriptNode.
|
|
*/
|
|
//Returns the first significant previous sibling.
|
|
Node *SPrev();
|
|
//Returns the first significant next sibling.
|
|
Node *SNext();
|
|
//Returns the first significant child.
|
|
Node *SFirstChild();
|
|
//Returns the last significant child.
|
|
Node *SLastChild();
|
|
void detachNode();
|
|
|
|
|
|
|
|
int size();
|
|
|
|
//set/get the corresponding DOM::Node of this node.
|
|
//See more informations about rootNode/leafNode below.
|
|
DOM::Node* rootNode() {return m_rootNode;}
|
|
DOM::Node* leafNode() { return m_leafNode;}
|
|
void setRootNode(DOM::Node *rootNode) {m_rootNode = rootNode;}
|
|
void setLeafNode(DOM::Node *leafNode) {m_leafNode = leafNode;}
|
|
Node* _closingNode;
|
|
|
|
/**
|
|
* The contents of the Node is inside the Tag. Should _never_ be null.
|
|
*/
|
|
Tag *tag;
|
|
|
|
TQValueList<TQListViewItem *> listItems; ///<points to the listview items which represents this node in the structure tree
|
|
TQListViewItem *mainListItem; ///< the main listview item (from under the root node) associated with this node
|
|
bool closesPrevious; //this node "closes" the tag from previous node
|
|
bool opened;
|
|
bool removeAll; //set to false if you don't want to remove the "next" and "child" when deleting the node.
|
|
bool insideSpecial; //true if the node is part of a special area
|
|
bool specialInsideXml; //< true if the node is a special area defined inside a tag, like the PHP in <a href="<? echo $a ?>">
|
|
TQString fileName; //the node is in this file. If empty, it's in the current document
|
|
TQValueList<GroupElement*> m_groupElements; ///< all the group elements pointing to this node
|
|
|
|
private:
|
|
/**
|
|
* For VPL use.
|
|
* Usually for a XmlTag or Text Node there is one corresponding DOM::Node. But sdmetimes there are more
|
|
* e.g. in the DOM::Node tree the TABLE DOM::Node require the TBODY DOM::Node even if not necessary according
|
|
* to the specs. So m_rootNode points to the TABLE DOM::Node and m_leafNode points to the TBODY DOM::Node.
|
|
*/
|
|
DOM::Node *m_rootNode, *m_leafNode;
|
|
};
|
|
|
|
#endif
|