TQt4 port kdewebdev

This enables compilation under both Qt3 and Qt4


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdewebdev@1237029 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 207 insertions, 207 deletions

diff --git a/quanta/parts/kafka/kafkacommon.cpp b/quanta/parts/kafka/kafkacommon.cpp
index 5d4c5714..0d15ca02 100644
--- a/quanta/parts/kafka/kafkacommon.cpp
+++ b/quanta/parts/kafka/kafkacommon.cpp
@@ -52,9 +52,9 @@ Node *kafkaCommon::getNextNode(Node *node, bool &goUp, Node *endNode)
         }
         else
         {
-            if(node->parent == endNode)
+            if(node->tqparent == endNode)
                 return 0L;
-            return getNextNode(node->parent, goUp);
+            return getNextNode(node->tqparent, goUp);
         }
     }
     else
@@ -74,9 +74,9 @@ Node *kafkaCommon::getNextNode(Node *node, bool &goUp, Node *endNode)
         else
         {
             goUp = true;
-            if(node->parent == endNode)
+            if(node->tqparent == endNode)
                 return 0L;
-            return getNextNode(node->parent, goUp);
+            return getNextNode(node->tqparent, goUp);
         }
     }
 }
@@ -119,7 +119,7 @@ Node* kafkaCommon::getPrevNode(Node *node, Node *endNode)
     }
     else
     {
-        n = n->parent;
+        n = n->tqparent;
         if(n == endNode)
             return 0L;
     }
@@ -171,13 +171,13 @@ Node* kafkaCommon::DTDGetCommonParent(Node* startNode, Node* endNode,
     if(commonParent && (commonParent->tag->type == Tag::Text || commonParent->tag->type == Tag::Empty))
     {
         Node* oldCommonParent = commonParent;
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
         commonParentStartChild = oldCommonParent;
         commonParentEndChild = oldCommonParent;
     }
     //startNode or endNode can't be the commonParent.
     else if(commonParent && (itStart == startNodeLocation.end() || itEnd == endNodeLocation.end()))
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
 
     commonParentStartChildLocation = getLocation(commonParentStartChild);
     commonParentEndChildLocation = getLocation(commonParentEndChild);
@@ -222,18 +222,18 @@ Node* kafkaCommon::DTDGetNonInlineCommonParent(Node* startNode, Node* endNode,
        commonParent->tag->type == Tag::Text || commonParent->tag->type == Tag::Empty))
     {
         Node* oldCommonParent = commonParent;
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
         while(commonParent && isInline(commonParent->tag->name))
         {
             oldCommonParent = commonParent;
-            commonParent = commonParent->parent;
+            commonParent = commonParent->tqparent;
         }
         commonParentStartChild = oldCommonParent;
         commonParentEndChild = oldCommonParent;
     }
     //startNode or endNode can't be the commonParent.
     else if(commonParent && (itStart == startNodeLocation.end() || itEnd == endNodeLocation.end()))
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
 
     commonParentStartChildLocation = getLocation(commonParentStartChild);
     commonParentEndChildLocation = getLocation(commonParentEndChild);
@@ -365,7 +365,7 @@ void kafkaCommon::applyIndentation(Node *node, int nbOfSpaces, int nbOfTabs, Nod
     kdDebug(25001)<< "kafkaCommon::applyIndentation()" << endl;
 #endif
 
-    Node *parent, *nextNE, *prevNE, *realPrevNE, *realNextNE, *realPrev, *realNext, *prev, *next;
+    Node *tqparent, *nextNE, *prevNE, *realPrevNE, *realNextNE, *realPrev, *realNext, *prev, *next;
     int nonInlineDepth = 0, nonInlineDepth2 = 0, i;
     bool b = false;
     TQString indentation1, indentation2, text;
@@ -383,12 +383,12 @@ void kafkaCommon::applyIndentation(Node *node, int nbOfSpaces, int nbOfTabs, Nod
     realNext = node->next;
 
     if(inlineNodeIndentation &&
-       !node->prev && getNodeDisplay(node->parent, true) == kafkaCommon::blockDisplay)
+       !node->prev && getNodeDisplay(node->tqparent, true) == kafkaCommon::blockDisplay)
     {
         AreaStruct node_area = node->tag->area();
-        AreaStruct parent_area = node->parent->tag->area();
+        AreaStruct tqparent_area = node->tqparent->tag->area();
 
-        if(node_area.bLine == parent_area.bLine)
+        if(node_area.bLine == tqparent_area.bLine)
         {
             node->tag->setIndentationDone(true);
             return;
@@ -400,30 +400,30 @@ void kafkaCommon::applyIndentation(Node *node, int nbOfSpaces, int nbOfTabs, Nod
         setTagString(node, removeUnnecessaryWhitespaces(node->tag->tagStr()), modifs);
 
     //compute the "non-inline depth" of the Node and of the next NE (not Empty) Node
-    // i.e. we count how many non-inline parent they have.
-    parent = node->parent;
-    while(parent)
+    // i.e. we count how many non-inline tqparent they have.
+    tqparent = node->tqparent;
+    while(tqparent)
     {
-        if(getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+        if(getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
             ++nonInlineDepth;
-        parent = parent->parent;
+        tqparent = tqparent->tqparent;
     }
 
     //compute the "non-inline depth" of the next non-empty Node.
     if (nextNE)
-        parent = nextNE->parent;
+        tqparent = nextNE->tqparent;
     else
-        parent = 0L;
-    while(parent)
+        tqparent = 0L;
+    while(tqparent)
     {
-        if(getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+        if(getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
             ++nonInlineDepth2;
-        parent = parent->parent;
+        tqparent = tqparent->tqparent;
     }
 
-    parent = node->parent;
+    tqparent = node->tqparent;
 
-    if(!parent || getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+    if(!tqparent || getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
     {
         //prepare the indentation
         indentation1 = "\n";
@@ -507,7 +507,7 @@ void kafkaCommon::applyIndentation(Node *node, int nbOfSpaces, int nbOfTabs, Nod
     }
     else
     {
-        //The parent is inline, so no indentation.
+        //The tqparent is inline, so no indentation.
         //Nothing to do.
     }
     node->tag->setIndentationDone(true);
@@ -519,7 +519,7 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
     kdDebug(25001)<< "kafkaCommon::fitIndentationNodes()" << endl;
 #endif
 
-    Node *parent, *child, *node, *emptyNode = 0L, *emptyNode2 = 0L;
+    Node *tqparent, *child, *node, *emptyNode = 0L, *emptyNode2 = 0L;
     int nbEmptyNodes = 0, n1Depth, n2Depth;
     bool lastChild = false, firstChild = false;
 
@@ -534,16 +534,16 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
         if(n1Depth > n2Depth)
         {
             child = n1;
-            parent = n2;
+            tqparent = n2;
         }
         else
         {
             child = n2;
-            parent = n1;
+            tqparent = n1;
         }
-        if(child->parent->firstChildNE() == child)
+        if(child->tqparent->firstChildNE() == child)
             firstChild = true;
-        if(child->parent->lastChildNE() == child)
+        if(child->tqparent->lastChildNE() == child)
             lastChild = true;
 
         //counting the Empty Nodes and deleting them to have only one empty node.
@@ -591,11 +591,11 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
         //adding/deleting a empty node if necessary
         if(firstChild)
         {
-            if(getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+            if(getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
             {
                 if(child->tag->type != Tag::Text && !emptyNode)
                 {
-                    createAndInsertNode("", "", Tag::Empty, n2->tag->write(), child->parent,
+                    createAndInsertNode("", "", Tag::Empty, n2->tag->write(), child->tqparent,
                                         child, child, modifs);
                 }
             }
@@ -610,11 +610,11 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
 
         if(lastChild)
         {
-            if(getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+            if(getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
             {
                 if(child->tag->type != Tag::Text && !emptyNode2)
                 {
-                    createAndInsertNode("", "", Tag::Empty, n2->tag->write(), child->parent,
+                    createAndInsertNode("", "", Tag::Empty, n2->tag->write(), child->tqparent,
                                         0L, 0L, modifs);
                 }
             }
@@ -654,8 +654,8 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
         }
 
         //adding/deleting a empty node if necessary
-        parent = n1->parent;
-        if(!parent || getNodeDisplay(parent, true) == kafkaCommon::blockDisplay)
+        tqparent = n1->tqparent;
+        if(!tqparent || getNodeDisplay(tqparent, true) == kafkaCommon::blockDisplay)
         {
             if(getNodeDisplay(n1, true) == kafkaCommon::blockDisplay &&
                     n1->tag->type != Tag::Text)
@@ -672,7 +672,7 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
                     }
                     else
                     {
-                        createAndInsertNode("", "", Tag::Empty, n2->tag->write(), parent, n2, n2, modifs);
+                        createAndInsertNode("", "", Tag::Empty, n2->tag->write(), tqparent, n2, n2, modifs);
                     }
                 }
             }
@@ -694,7 +694,7 @@ void kafkaCommon::fitIndentationNodes(Node *n1, Node *n2, NodeModifsSet *modifs)
                     }
                     else
                     {
-                        createAndInsertNode("", "", Tag::Empty, n2->tag->write(), parent, n2, n2, modifs);
+                        createAndInsertNode("", "", Tag::Empty, n2->tag->write(), tqparent, n2, n2, modifs);
                     }
                 }
             }
@@ -770,7 +770,7 @@ int kafkaCommon::getNodeDisplay(Node *node, bool closingNodeToo)
             closingNodeToo))
     {
         //If we areusing a non (X)HTML DTD, make everything blockDisplay by default
-        if(node->tag->dtd() && node->tag->dtd()->name.contains("HTML", false) == 0)
+        if(node->tag->dtd() && node->tag->dtd()->name.tqcontains("HTML", false) == 0)
             return kafkaCommon::blockDisplay;
 
         nodeName = node->tag->name.lower();
@@ -948,7 +948,7 @@ Node *kafkaCommon::createXmlDeclarationNode(Document *doc, const TQString &encod
 
 Node* kafkaCommon::createMandatoryNodeSubtree(Node *node, Document *doc)
 {
-    QTag *nodeQTag, *oldNodeQTag;
+    TQTag *nodeTQTag, *oldNodeTQTag;
     bool searchForMandatoryNode;
     Node *currentParent;
     TQMap<TQString, bool>::iterator it;
@@ -956,28 +956,28 @@ Node* kafkaCommon::createMandatoryNodeSubtree(Node *node, Document *doc)
     if(!node)
         return 0L;
 
-    nodeQTag = QuantaCommon::tagFromDTD(node);
-    if(!nodeQTag)
+    nodeTQTag = QuantaCommon::tagFromDTD(node);
+    if(!nodeTQTag)
         return false;
 
     searchForMandatoryNode = true;
     currentParent = node;
     while(searchForMandatoryNode)
     {
-        oldNodeQTag = nodeQTag;
-        for(it = nodeQTag->childTags.begin(); it != nodeQTag->childTags.end(); ++it)
+        oldNodeTQTag = nodeTQTag;
+        for(it = nodeTQTag->childTags.begin(); it != nodeTQTag->childTags.end(); ++it)
         {
             if(it.data())
             {
-                nodeQTag = QuantaCommon::tagFromDTD(nodeQTag->parentDTD, it.key());
-                if(!nodeQTag)
+                nodeTQTag = QuantaCommon::tagFromDTD(nodeTQTag->tqparentDTD, it.key());
+                if(!nodeTQTag)
                     return node;
-                currentParent = createAndInsertNode(nodeQTag->name(), "", Tag::XmlTag, doc,
+                currentParent = createAndInsertNode(nodeTQTag->name(), "", Tag::XmlTag, doc,
                                                     currentParent, 0L, 0L, (NodeModifsSet*)0L);
                 break;
             }
         }
-        if(oldNodeQTag == nodeQTag)
+        if(oldNodeTQTag == nodeTQTag)
             searchForMandatoryNode = false;
     }
 
@@ -998,7 +998,7 @@ Node* kafkaCommon::insertNode(Node *node, Node* parentNode, Node* nextSibling,
     if(!node)
         return 0L;
 
-    //Reset the listviews items pointers for node and its children
+    //Reset the listviews items pointers for node and its tqchildren
     n = node;
     b = false;
     while(n)
@@ -1028,7 +1028,7 @@ Node* kafkaCommon::insertNode(Node *node, Node* parentNode, Node* nextSibling,
         nodeIsFirstChild = true;
         parentNode->child = node;
     }
-    node->parent = parentNode;
+    node->tqparent = parentNode;
 
     if(nextSibling && nextSibling->prev)
     {
@@ -1099,7 +1099,7 @@ Node* kafkaCommon::insertNode(Node *node, Node* parentNode, Node* nextSibling, N
     if(!node)
         return 0L;
 
-    //Reset the listviews items pointers for node and its children
+    //Reset the listviews items pointers for node and its tqchildren
     n = node;
     b = false;
     while(n)
@@ -1129,7 +1129,7 @@ Node* kafkaCommon::insertNode(Node *node, Node* parentNode, Node* nextSibling, N
         nodeIsFirstChild = true;
         parentNode->child = node;
     }
-    node->parent = parentNode;
+    node->tqparent = parentNode;
 
     if(nextSibling && nextSibling->prev)
     {
@@ -1186,7 +1186,7 @@ Node* kafkaCommon::insertNode(Node *node, Node* parentNode, Node* nextSibling, N
     return node;
 }
 
-Node *kafkaCommon::insertNode(Node *newNode, Node *parent, Node *nextSibling, Node *nextEndSibling,
+Node *kafkaCommon::insertNode(Node *newNode, Node *tqparent, Node *nextSibling, Node *nextEndSibling,
                               NodeModifsSet *modifs, bool merge)
 {
 #ifdef LIGHT_DEBUG
@@ -1199,7 +1199,7 @@ Node *kafkaCommon::insertNode(Node *newNode, Node *parent, Node *nextSibling, No
         return 0L;
 
     //place the new Node.
-    newNode = insertNode(newNode, parent, nextSibling, modifs, merge);
+    newNode = insertNode(newNode, tqparent, nextSibling, modifs, merge);
 
     if(!newNode->tag->single && newNode->tag->type == Tag::XmlTag)
     {
@@ -1208,7 +1208,7 @@ Node *kafkaCommon::insertNode(Node *newNode, Node *parent, Node *nextSibling, No
         nodeEnd->closesPrevious = true;
 
         //place the new closing Node.
-        nodeEnd = insertNode(nodeEnd, parent, nextEndSibling, modifs, merge);
+        nodeEnd = insertNode(nodeEnd, tqparent, nextEndSibling, modifs, merge);
     }
 
     //If nextSibling != nextEndSibling, move all Nodes between node and nodeEnd as child of node
@@ -1222,7 +1222,7 @@ Node *kafkaCommon::insertNode(Node *newNode, Node *parent, Node *nextSibling, No
     return newNode;
 }
 
-Node* kafkaCommon::insertNode(Node *newNode, Node *parent, Node *startNodeToSurround,
+Node* kafkaCommon::insertNode(Node *newNode, Node *tqparent, Node *startNodeToSurround,
                               Node *endNodeToSurround, int startOffset, int endOffset, NodeModifsSet *modifs)
 {
 #ifdef LIGHT_DEBUG
@@ -1246,7 +1246,7 @@ Node* kafkaCommon::insertNode(Node *newNode, Node *parent, Node *startNodeToSurr
         endNodeToSurround = endNodeToSurround->next;
 
     //Then create and insert the new Node.
-    return insertNode(newNode, parent, startNodeToSurround,
+    return insertNode(newNode, tqparent, startNodeToSurround,
                       endNodeToSurround, modifs);
 }
 
@@ -1389,13 +1389,13 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
     {
         *cursorNode = newNode;
         cursorOffset = newNode->tag->tagStr().length();
-        return insertNodeSubtree(newNode, startNode->parent, endNode, modifs);
+        return insertNodeSubtree(newNode, startNode->tqparent, endNode, modifs);
     }
 
     //Then we "split" the lastValidStartParent - startNode subtree into two : the first part is untouched
     // and the second will be surrounded by the new Node. Same thing for endNode.
     Node* node = startNode;
-    Node* parentNode = startNode->parent;
+    Node* parentNode = startNode->tqparent;
     Node* newParentNode = 0, *child = 0, *next = 0;
     while(parentNode && commonParent && parentNode != commonParent)
     {
@@ -1404,10 +1404,10 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
             //node is not the first Child of parentNode, we have to duplicate parentNode, and put node and
             //all its next sibling as child of the new parentNode.
             /**newParentNode = insertNode(parentNode->tag->name, parentNode->tag->tagStr(),
-            parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
+            parentNode->tag->type, parentNode->tag->write(), parentNode->tqparentNode(),
             parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
             child = parentNode->firstChild();
             if(cursorOffset != 0)
             {
@@ -1433,13 +1433,13 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
         }
         //commonParentStartChild = parentNode;
         node = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
 
     if(endNode)
     {
         node = endNode;
-        parentNode = endNode->parent;
+        parentNode = endNode->tqparent;
         while(parentNode && commonParent && parentNode != commonParent)
         {
             if(true/*node != parentNode->firstChild()*/)
@@ -1447,10 +1447,10 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
             //node is not the first Child of parentNode, we have to duplicate parentNode, and put node and
             //all its next sibling as child of the new parentNode.
             /**newParentNode = insertNode(parentNode->tag->name, parentNode->tag->tagStr(),
-                parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
+                parentNode->tag->type, parentNode->tag->write(), parentNode->tqparentNode(),
                 parentNode, parentNode, modifs);*/
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
                 child = parentNode->firstChild();
                 while(child /*&& child == endNode*/ &&
                       (child == endNode || child->hasForChild(endNode)/* ||
@@ -1464,7 +1464,7 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
             commonParentStartChild = newParentNode;
             node = parentNode;
             Node* aux = parentNode;
-            parentNode = parentNode->parent;
+            parentNode = parentNode->tqparent;
             // Remove node subtree if empty
             if(!aux->hasChildNodes())
                 extractAndDeleteNode(aux, modifs);
@@ -1487,8 +1487,8 @@ Node* kafkaCommon::DTDInsertNodeSubtree(Node *newNode, NodeSelectionInd& selecti
 Node* kafkaCommon::DTDInsertNodeSubtree(Node* newNode, Node* parentNode, Node* nextSibling,
                                         NodeSelection& /*cursorHolder*/, NodeModifsSet *modifs)
 {
-    QTag* nodeQTag = QuantaCommon::tagFromDTD(parentNode);
-    if(!nodeQTag || !nodeQTag->isChild(newNode))
+    TQTag* nodeTQTag = QuantaCommon::tagFromDTD(parentNode);
+    if(!nodeTQTag || !nodeTQTag->isChild(newNode))
         return 0;
     else
         return insertNodeSubtree(newNode, parentNode, nextSibling, modifs);
@@ -1506,7 +1506,7 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
     Node *commonParent = 0L, *commonParentStartChild, *commonParentEndChild, *parentNode, *node;
     Node *lastValidStartParent = 0L, *lastValidEndParent = 0L, *newParentNode, *child, *next;
     Node *oldCommonParent, *lastNewNode, *oldParentNode;
-    QTag *parentNodeQTag = 0, *newNodeQTag, *lastNewNodeQTag;
+    TQTag *parentNodeTQTag = 0, *newNodeTQTag, *lastNewNodeTQTag;
     NodeModif modif;
     int locOffset = 1;
     bool newNodeIsInline, isAfter;
@@ -1519,16 +1519,16 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
 
     //FIrst get the mandatory Nodes if necessary, and get the qTag of the first and last Node.
     lastNewNode = createMandatoryNodeSubtree(newNode, doc);
-    lastNewNodeQTag = QuantaCommon::tagFromDTD(lastNewNode);
-    newNodeQTag = QuantaCommon::tagFromDTD(newNode);
-    if(!newNodeQTag || !lastNewNodeQTag)
+    lastNewNodeTQTag = QuantaCommon::tagFromDTD(lastNewNode);
+    newNodeTQTag = QuantaCommon::tagFromDTD(newNode);
+    if(!newNodeTQTag || !lastNewNodeTQTag)
     {
       Node::deleteNode(newNode);
       return false;
     }
 
-    //Then search for the common parent of startNode and endNode (commonParent)
-    //and for the childs of commonParent which are parent of startNode and endNode
+    //Then search for the common tqparent of startNode and endNode (commonParent)
+    //and for the childs of commonParent which are tqparent of startNode and endNode
     //(commonParentStartChild && commonParentEndChild)
     //CommonParent will be the limit (startNode -- commonNode) where Nodes can
     //be splitted in order to insert the newNode.
@@ -1559,51 +1559,51 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
                                             commonParent->tag->type == Tag::Text || commonParent->tag->type == Tag::Empty))
     {
         oldCommonParent = commonParent;
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
         while(commonParent && isInline(commonParent->tag->name))
         {
             oldCommonParent = commonParent;
-            commonParent = commonParent->parent;
+            commonParent = commonParent->tqparent;
         }
         commonParentStartChild = oldCommonParent;
         commonParentEndChild = oldCommonParent;
     }
     //startNode or endNode can't be the commonParent.
     else if(commonParent && (itStart == startNodeLocation.end() || itEnd == endNodeLocation.end()))
-        commonParent = commonParent->parent;
+        commonParent = commonParent->tqparent;
 
-    //Now look if at least one of the parent Nodes between startNode and commonParent
+    //Now look if at least one of the tqparent Nodes between startNode and commonParent
     //can have nodeName as child. If so for startNode and endNode, let's find the last
-    //parent Nodes which can have nodeName as child.
-    parentNode = startNode->parent;
+    //tqparent Nodes which can have nodeName as child.
+    parentNode = startNode->tqparent;
     oldParentNode = startNode;
-    while(parentNode && commonParent && parentNode != commonParent->parent)
+    while(parentNode && commonParent && parentNode != commonParent->tqparent)
     {
-        parentNodeQTag = QuantaCommon::tagFromDTD(parentNode);
-        if(parentNodeQTag && parentNodeQTag->isChild(newNode) &&
-                lastNewNodeQTag->isChild(oldParentNode))
+        parentNodeTQTag = QuantaCommon::tagFromDTD(parentNode);
+        if(parentNodeTQTag && parentNodeTQTag->isChild(newNode) &&
+                lastNewNodeTQTag->isChild(oldParentNode))
             lastValidStartParent = parentNode;
         else if(newNodeIsInline || !isInline(parentNode->tag->name))
             break;
         //else if(!newNodeIsInline && isInline(parentNode)), we continue : BLOCK element can
         //cut some inline tag in order to be inserted.
         oldParentNode = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
-    parentNode = endNode->parent;
+    parentNode = endNode->tqparent;
     oldParentNode = endNode;
-    while(parentNode && commonParent &&  parentNode != commonParent->parent)
+    while(parentNode && commonParent &&  parentNode != commonParent->tqparent)
     {
-        parentNodeQTag = QuantaCommon::tagFromDTD(parentNode);
-        if(parentNodeQTag && parentNodeQTag->isChild(newNode) &&
-                lastNewNodeQTag->isChild(oldParentNode))
+        parentNodeTQTag = QuantaCommon::tagFromDTD(parentNode);
+        if(parentNodeTQTag && parentNodeTQTag->isChild(newNode) &&
+                lastNewNodeTQTag->isChild(oldParentNode))
             lastValidEndParent = parentNode;
         else if(newNodeIsInline || !isInline(parentNode->tag->name))
             break;
         //else if(!newNodeIsInline && isInline(parentNode)), we continue : BLOCK element can
         //cut some inline tag in order to be inserted.
         oldParentNode = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
 
     /**if(!lastValidEndParent || !lastValidStartParent)
@@ -1662,7 +1662,7 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
     node = startNode;
     if (!startNode) //Andras: it can happen.
       return false;
-    parentNode = startNode->parent;
+    parentNode = startNode->tqparent;
     while(lastValidStartParent && parentNode && parentNode != lastValidStartParent)
     {
         if(node != parentNode->firstChild())
@@ -1670,10 +1670,10 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
             //node is not the first Child of parentNode, we have to duplicate parentNode, and put node and
             //all its next sibling as child of the new parentNode.
             /**newParentNode = insertNode(parentNode->tag->name, parentNode->tag->tagStr(),
-            	parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
+            	parentNode->tag->type, parentNode->tag->write(), parentNode->tqparentNode(),
             	parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
             child = parentNode->firstChild();
             while(child && child != startNode && !child->hasForChild(startNode))
             {
@@ -1683,10 +1683,10 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
             }
         }
         node = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
     node = endNode;
-    parentNode = endNode->parent;
+    parentNode = endNode->tqparent;
     while(lastValidEndParent && parentNode && parentNode != lastValidEndParent)
     {
         if(node != parentNode->lastChild())
@@ -1694,10 +1694,10 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
             //node is not the last Child of parentNode, we have to duplicate parentNode, and put all
             //the next sibling of node as child of the new parentNode
             /**newParentNode = insertNode(parentNode->tag->name, parentNode->tag->tagStr(),
-            	parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
+            	parentNode->tag->type, parentNode->tag->write(), parentNode->tqparentNode(),
             	parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
             if(parentNode == commonParentStartChild)
                 commonParentStartChild = newParentNode;
             if(parentNode == commonParentEndChild)
@@ -1717,7 +1717,7 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
             }
         }
         node = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
 
     //Now if startNode is after endNode, this means that a selectionless insertion is being done.
@@ -1728,19 +1728,19 @@ bool kafkaCommon::DTDinsertNode(Node *newNode, Node *startNode, int startOffset,
                    (signed)startNode->tag->tagStr().length() == startOffset))
     {
         if(isAfter)
-            parentNodeQTag = QuantaCommon::tagFromDTD(commonParent);
+            parentNodeTQTag = QuantaCommon::tagFromDTD(commonParent);
         else if((signed)startNode->tag->tagStr().length() == startOffset && startNode->tag->type == Tag::XmlTag)
-            parentNodeQTag = QuantaCommon::tagFromDTD(startNode);
+            parentNodeTQTag = QuantaCommon::tagFromDTD(startNode);
         else if((signed)startNode->tag->tagStr().length() == startOffset && startNode->tag->type == Tag::XmlTagEnd)
-            parentNodeQTag = QuantaCommon::tagFromDTD(startNode->parent);
-        if(!parentNodeQTag || (parentNodeQTag && parentNodeQTag->isChild(newNode)))
+            parentNodeTQTag = QuantaCommon::tagFromDTD(startNode->tqparent);
+        if(!parentNodeTQTag || (parentNodeTQTag && parentNodeTQTag->isChild(newNode)))
         {
             if(isAfter)
                 insertNodeSubtree(newNode, commonParent, commonParentStartChild, modifs);
             else if((signed)startNode->tag->tagStr().length() == startOffset && startNode->tag->type == Tag::XmlTag)
                 insertNodeSubtree(newNode, startNode, 0L, modifs);
             else if((signed)startNode->tag->tagStr().length() == startOffset && startNode->tag->type == Tag::XmlTagEnd)
-                insertNodeSubtree(newNode, startNode->parent, startNode->next, modifs);
+                insertNodeSubtree(newNode, startNode->tqparent, startNode->next, modifs);
             //<TEMPORARY>
             (*cursorNode) = lastNewNode;
             cursorOffset = 0;
@@ -1798,7 +1798,7 @@ bool kafkaCommon::DTDinsertRemoveNode(Node *newNode, Node *startNode, int startO
 }
 
 Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString &tagString,
-                                       int nodeType, Document *doc, Node* parent, Node* nextSibling, NodeModifsSet *modifs,
+                                       int nodeType, Document *doc, Node* tqparent, Node* nextSibling, NodeModifsSet *modifs,
                                        bool merge)
 {
 #ifdef LIGHT_DEBUG
@@ -1812,13 +1812,13 @@ Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString
     node = createNode(nodeName, tagString, nodeType, doc);
 
     //insert the new Node.
-    insertNode(node, parent, nextSibling, modifs, merge);
+    insertNode(node, tqparent, nextSibling, modifs, merge);
 
     return node;
 }
 
 Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString &tagString,
-                                       int nodeType, Document *doc, Node *parent, Node *nextSibling, Node *nextEndSibling,
+                                       int nodeType, Document *doc, Node *tqparent, Node *nextSibling, Node *nextEndSibling,
                                        NodeModifsSet *modifs)
 {
 #ifdef LIGHT_DEBUG
@@ -1832,13 +1832,13 @@ Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString
     node = createNode(nodeName, tagString, nodeType, doc);
 
     //insert the new Node.
-    insertNode(node, parent, nextSibling, nextEndSibling, modifs);
+    insertNode(node, tqparent, nextSibling, nextEndSibling, modifs);
 
     return node;
 }
 
 Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString &tagString,
-                                       int nodeType, Document *doc, Node *parent, Node *startNodeToSurround,
+                                       int nodeType, Document *doc, Node *tqparent, Node *startNodeToSurround,
                                        Node *endNodeToSurround, int startOffset, int endOffset, NodeModifsSet *modifs)
 {
 #ifdef LIGHT_DEBUG
@@ -1855,7 +1855,7 @@ Node *kafkaCommon::createAndInsertNode(const TQString &nodeName, const TQString
     node = createNode(nodeName, tagString, nodeType, doc);
 
     //insert the new Node.
-    insertNode(node, parent, startNodeToSurround, endNodeToSurround, startOffset, endOffset,
+    insertNode(node, tqparent, startNodeToSurround, endNodeToSurround, startOffset, endOffset,
                modifs);
 
     return node;
@@ -1891,18 +1891,18 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
                                      NodeModifsSet *modifs)
 {
 
-    QTag *leafNodeQTag, *currentNodeParentQTag;
+    TQTag *leafNodeTQTag, *currentNodeParentTQTag;
     Node *startSelection = 0L, *endSelection = 0L, *oldCurrentNode, *copyNewNode;
     bool selectionInProgress = false, validCurNodeParent = false;
 
-    leafNodeQTag = QuantaCommon::tagFromDTD(leafNode);
-    if(!leafNodeQTag)
+    leafNodeTQTag = QuantaCommon::tagFromDTD(leafNode);
+    if(!leafNodeTQTag)
         return false;
 
-    if(currentNode && currentNode->parent)
+    if(currentNode && currentNode->tqparent)
     {
-        currentNodeParentQTag = QuantaCommon::tagFromDTD(currentNode->parent);
-        if(currentNodeParentQTag && currentNodeParentQTag->isChild(newNode))
+        currentNodeParentTQTag = QuantaCommon::tagFromDTD(currentNode->tqparent);
+        if(currentNodeParentTQTag && currentNodeParentTQTag->isChild(newNode))
             validCurNodeParent = true;
     }
 
@@ -1924,7 +1924,7 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
         //if the examination has started and currentNode doesn't have endExaminationNode as
         //child, let's start/extend the selection over this node.
         if((currentNode->tag->type == Tag::XmlTag || currentNode->tag->type == Tag::Text) &&
-                leafNodeQTag->isChild(currentNode) && validCurNodeParent && examinationStarted &&
+                leafNodeTQTag->isChild(currentNode) && validCurNodeParent && examinationStarted &&
                 !currentNode->hasForChild(endExaminationNode))
         {
 #ifdef HEAVY_DEBUG
@@ -1986,10 +1986,10 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
                     if (startSelection && endSelection)
                     {
                       /**copyNewNode = duplicateNode(newNode);
-                      insertNode(copyNewNode, startSelection->parentNode(), startSelection,
+                      insertNode(copyNewNode, startSelection->tqparentNode(), startSelection,
                         endSelection->next, modifs);*/
                       copyNewNode = duplicateNodeSubtree(newNode);
-                      insertNodeSubtree(copyNewNode, startSelection->parentNode(), startSelection,
+                      insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
                                         endSelection->next, modifs);
                       nodeInserted = true;
                     }
@@ -2067,10 +2067,10 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
                 if (startSelection && endSelection)
                 {
                   /**copyNewNode = duplicateNode(newNode);
-                  insertNode(copyNewNode, startSelection->parentNode(), startSelection,
+                  insertNode(copyNewNode, startSelection->tqparentNode(), startSelection,
                     endSelection->next, modifs);*/
                   copyNewNode = duplicateNodeSubtree(newNode);
-                  insertNodeSubtree(copyNewNode, startSelection->parentNode(), startSelection,
+                  insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
                                     endSelection->next, modifs);
                   nodeInserted = true;
                 }
@@ -2097,10 +2097,10 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
             while(endSelection && endSelection->tag->type == Tag::Empty)
                 endSelection = endSelection->prev;
             /**copyNewNode = duplicateNode(newNode);
-            insertNode(copyNewNode, startSelection->parentNode(), startSelection,
+            insertNode(copyNewNode, startSelection->tqparentNode(), startSelection,
             	endSelection->next, modifs);*/
             copyNewNode = duplicateNodeSubtree(newNode);
-            insertNodeSubtree(copyNewNode, startSelection->parentNode(), startSelection,
+            insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
                               endSelection->next, modifs);
             nodeInserted = true;
         }
@@ -2184,7 +2184,7 @@ Node *kafkaCommon::duplicateNodeSubtree(Node *node, bool childAndClosingTagOnly)
         newPrev = 0L;
         for(link = nodeLinkList.first(); link; link = nodeLinkList.next())
         {
-            if(link->m_n1 == currentNode->parent)
+            if(link->m_n1 == currentNode->tqparent)
                 newParent = link->m_n2;
             else if(link->m_n1 == currentNode->next)
                 newNext = link->m_n2;
@@ -2217,7 +2217,7 @@ Node* kafkaCommon::extractNode(Node *node, NodeModifsSet *modifs, bool extractCh
 {
     NodeModif *modif = 0, *modifChild;
     Node *lastChild, *curNode;
-    Node *parent, *next, *child, *n;
+    Node *tqparent, *next, *child, *n;
     //Node *prev;
     bool isSingle;
     int type;
@@ -2231,7 +2231,7 @@ Node* kafkaCommon::extractNode(Node *node, NodeModifsSet *modifs, bool extractCh
     if(!node->child)
         extractChildren = true;
 
-    parent = node->parent;
+    tqparent = node->tqparent;
     next = node->next;
     //prev = node->prev; //Should this be used at all?
     child = node->child;
@@ -2252,7 +2252,7 @@ Node* kafkaCommon::extractNode(Node *node, NodeModifsSet *modifs, bool extractCh
             modif->setType(NodeModif::NodeRemoved);
         modif->setLocation(getLocation(node));
 
-        //log the children move if we don't extract the children
+        //log the tqchildren move if we don't extract the tqchildren
         if(!extractChildren)
         {
           location = getLocation(node);
@@ -2284,18 +2284,18 @@ Node* kafkaCommon::extractNode(Node *node, NodeModifsSet *modifs, bool extractCh
         curNode = node->child;
         while(curNode)
         {
-            curNode->parent = node->parent;
+            curNode->tqparent = node->tqparent;
             curNode = curNode->next;
         }
     }
-    if(node->parent && node->parent->child == node)
+    if(node->tqparent && node->tqparent->child == node)
     {
         if(extractChildren)
-            node->parent->child = node->next;
+            node->tqparent->child = node->next;
         else
-            node->parent->child = node->child;
+            node->tqparent->child = node->child;
     }
-    node->parent = 0L;
+    node->tqparent = 0L;
     if(node->prev)
     {
         if(extractChildren)
@@ -2643,7 +2643,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
                                 int startOffset, Node *endNode, int endOffset, Node **cursorNode, long &cursorOffset,
                                 NodeModifsSet *modifs)
 {
-    QTag *nodeNameQTag, *parentQTag;
+    TQTag *nodeNameTQTag, *tqparentTQTag;
     Node *node, *lastNodeNameStartNode, *lastNodeNameEndNode;
     Node *parentNode, *newParentNode, *child, *next;
     bool goUp, nodesRemoved = false, DTDError = false, result;
@@ -2653,8 +2653,8 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
         return kafkaCommon::extractionBadParameters;
 
     //First check that nodeName is really inline and that an area is selected.
-    nodeNameQTag = QuantaCommon::tagFromDTD(doc->defaultDTD(), nodeName);
-    if(!nodeNameQTag)
+    nodeNameTQTag = QuantaCommon::tagFromDTD(doc->defaultDTD(), nodeName);
+    if(!nodeNameTQTag)
         return kafkaCommon::extractionBadParameters;
     if(!isInline(nodeName))
         return kafkaCommon::extractionBadParameters;
@@ -2671,8 +2671,8 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
     if(startNode == endNode && startOffset == endOffset)
         return kafkaCommon::extractionBadParameters;
 
-    //Then, process startNode and endNode : look if a nodeName parent is one of
-    //startNode/endNode's inline parents and if it is the case, split the necessary Nodes.
+    //Then, process startNode and endNode : look if a nodeName tqparent is one of
+    //startNode/endNode's inline tqparents and if it is the case, split the necessary Nodes.
     //The comparaison is made in lowercase, even in xml : it could be strange, for an user, to have
     //its nodes not removed because there are in the wrong case.
     node = startNode;
@@ -2681,7 +2681,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
     {
         if(node->tag->name.lower() == nodeName.lower())
             lastNodeNameStartNode = node;
-        node = node->parent;
+        node = node->tqparent;
     }
     node = endNode;
     lastNodeNameEndNode = 0L;
@@ -2689,7 +2689,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
     {
         if(node->tag->name.lower() == nodeName.lower())
             lastNodeNameEndNode = node;
-        node = node->parent;
+        node = node->tqparent;
     }
 
     if(startNode->tag->type == Tag::Text)
@@ -2724,13 +2724,13 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
     if(lastNodeNameStartNode)
     {
         node = startNode;
-        parentNode = startNode->parent;
-        while(parentNode && parentNode != lastNodeNameStartNode->parent)
+        parentNode = startNode->tqparent;
+        while(parentNode && parentNode != lastNodeNameStartNode->tqparent)
         {
             if(node != parentNode->firstChild())
             {
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
                 child = parentNode->firstChild();
                 while(child && child != startNode && !child->hasForChild(startNode))
                 {
@@ -2740,19 +2740,19 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
                 }
             }
             node = parentNode;
-            parentNode = parentNode->parent;
+            parentNode = parentNode->tqparent;
         }
     }
     if(lastNodeNameEndNode)
     {
         node = endNode;
-        parentNode = endNode->parent;
-        while(parentNode && parentNode != lastNodeNameEndNode->parent)
+        parentNode = endNode->tqparent;
+        while(parentNode && parentNode != lastNodeNameEndNode->tqparent)
         {
             if(node != parentNode->SLastChild())
             {
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
                 if(parentNode == lastNodeNameStartNode)
                     lastNodeNameStartNode = newParentNode;
                 child = parentNode->firstChild();
@@ -2770,7 +2770,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
                 }
             }
             node = parentNode;
-            parentNode = parentNode->parent;
+            parentNode = parentNode->tqparent;
         }
     }
 
@@ -2782,13 +2782,13 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
         next = getNextNode(node, goUp);
         if(node->tag->type == Tag::XmlTag && node->tag->name.lower() == nodeName.lower())
         {
-            parentQTag = QuantaCommon::tagFromDTD(node->parent);
-            if(parentQTag)
+            tqparentTQTag = QuantaCommon::tagFromDTD(node->tqparent);
+            if(tqparentTQTag)
             {
                 child = node->firstChild();
                 while(child)
                 {
-                    if(!parentQTag->isChild(child))
+                    if(!tqparentTQTag->isChild(child))
                         DTDError = true;
                     child = child->next;
                 }
@@ -2927,10 +2927,10 @@ bool kafkaCommon::splitNode(Node *n, int offset, NodeModifsSet *modifs)
 
     if(n->tag->type == Tag::Text)
         node = createAndInsertNode("#text", tagStr.right(tagStr.length() - offset), Tag::Text, n->tag->write(),
-                                   n->parent, n->next, modifs, false);
+                                   n->tqparent, n->next, modifs, false);
     else
         node = createAndInsertNode("", tagStr.right(tagStr.length() - offset), Tag::Empty, n->tag->write(),
-                                   n->parent, n->next, modifs, false);
+                                   n->tqparent, n->next, modifs, false);
 
     //Node's string is a part of n's clean string
     node->tag->setCleanStrBuilt(true);
@@ -2944,14 +2944,14 @@ void kafkaCommon::splitStartNodeSubtree(Node* startNode, Node* commonParent,
     //Then we "split" the lastValidStartParent - startNode subtree into two : the first part is untouched
     // and the second will be surrounded by the new Node. Same thing for endNode.
     Node* node = startNode;
-    Node* parentNode = startNode->parent;
+    Node* parentNode = startNode->tqparent;
     Node* commonParentStartChild = 0;
     while(parentNode && commonParent && parentNode != commonParent)
     {
         if(node != parentNode->firstChild())
         {
             Node* newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
             Node* child = parentNode->firstChild();
             while(child && child != startNode && !child->hasForChild(startNode))
             {
@@ -2962,7 +2962,7 @@ void kafkaCommon::splitStartNodeSubtree(Node* startNode, Node* commonParent,
         }
         commonParentStartChild = parentNode;
         node = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
 
     if(commonParentStartChild)
@@ -2975,7 +2975,7 @@ void kafkaCommon::splitEndNodeSubtree(Node* endNode, Node* commonParent,
                                       bool subTree, NodeModifsSet* modifs)
 {
     Node* node = endNode;
-    Node* parentNode = endNode->parent;
+    Node* parentNode = endNode->tqparent;
 
     Node* aux = 0;
     if(subTree)
@@ -2989,7 +2989,7 @@ void kafkaCommon::splitEndNodeSubtree(Node* endNode, Node* commonParent,
         if(node != parentNode->lastChild())
         {
             Node* newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
             if(parentNode == commonParentStartChild)
                 commonParentStartChild = newParentNode;
             if(parentNode == commonParentEndChild)
@@ -3009,7 +3009,7 @@ void kafkaCommon::splitEndNodeSubtree(Node* endNode, Node* commonParent,
             }
         }
         node = parentNode;
-        parentNode = parentNode->parent;
+        parentNode = parentNode->tqparent;
     }
     commonParentStartChildLocation = getLocation(commonParentStartChild);
     commonParentEndChildLocation = getLocation(commonParentEndChild);
@@ -3029,11 +3029,11 @@ void kafkaCommon::splitStartAndEndNodeSubtree(Node*& startNode, int startOffset,
     startNode = getCorrectStartNode(startNode, startOffset);
     endNode = getCorrectEndNode(endNode, endOffset);
 
-    // look for common parent
+    // look for common tqparent
     if(!commonParent)
     {
         if(extractInlineParentNodes)
-            // get the non inline common parent
+            // get the non inline common tqparent
             commonParent =
                     DTDGetNonInlineCommonParent(startNode, endNode, commonParentStartChildLocation, commonParentEndChildLocation, subTree);
         else
@@ -3075,7 +3075,7 @@ void kafkaCommon::splitStartAndEndNodeSubtree(Node*& startNode, int startOffset,
     }
     splitNode(endNode, endOffset, modifs);
 
-    // split start and end nodes subtree in function of common parent
+    // split start and end nodes subtree in function of common tqparent
     commonParentStartChildLocation = kafkaCommon::getLocation(commonParentStartChild);
     splitStartNodeSubtree(startNode, commonParent, commonParentStartChildLocation, modifs);
 
@@ -3208,21 +3208,21 @@ bool kafkaCommon::mergeNodes(Node *n, Node *n2, NodeSelection& cursorHolder, Nod
 void kafkaCommon::mergeInlineNode(Node *startNode, Node *endNode, Node **cursorNode,
                                   long &cursorOffset, NodeModifsSet *modifs)
 {
-    Node *startNodeLastInlineParent, *parent, *node, *next;
+    Node *startNodeLastInlineParent, *tqparent, *node, *next;
     bool goUp, success, isCursorNode, isEndNode;
     int nodeLength;
 
     if(!startNode || !endNode)
         return;
 
-    //first search for the last inline parent of startNode, and then its last prev neighbour
+    //first search for the last inline tqparent of startNode, and then its last prev neighbour
     // which is also inline : the merge will start from this Node.
     startNodeLastInlineParent = startNode;
-    parent = startNode->parent;
-    while(parent && isInline(parent->tag->name))
+    tqparent = startNode->tqparent;
+    while(tqparent && isInline(tqparent->tag->name))
     {
-        startNodeLastInlineParent = parent;
-        parent = parent->parent;
+        startNodeLastInlineParent = tqparent;
+        tqparent = tqparent->tqparent;
     }
     if(startNodeLastInlineParent->prev)
     {
@@ -3297,7 +3297,7 @@ void kafkaCommon::getEndPosition(const TQString &tagString, int bLine, int bCol,
 {
     /**int result, oldResult;
 
-    result = tagString.find("\n", 0);
+    result = tagString.tqfind("\n", 0);
     if(result == -1)
     {
     	eLine = bLine;
@@ -3310,7 +3310,7 @@ void kafkaCommon::getEndPosition(const TQString &tagString, int bLine, int bCol,
     	{
     		eLine++;
     		oldResult = result;
-    		result = tagString.find("\n", result + 1);
+    		result = tagString.tqfind("\n", result + 1);
     	}
     	eCol = tagString.length() - oldResult - 2;
     }*/
@@ -3420,7 +3420,7 @@ TQValueList<int> kafkaCommon::getLocation(Node * node)
             node = node->prev;
         }
         loc.prepend(i);
-        node = node->parent;
+        node = node->tqparent;
     }
     return loc;
 }
@@ -3634,11 +3634,11 @@ int kafkaCommon::nodeDepth(Node *node)
     if(!node)
         return -1;
 
-    node = node->parent;
+    node = node->tqparent;
     while(node)
     {
         depth++;
-        node = node->parent;
+        node = node->tqparent;
     }
 
     return depth;
@@ -3646,12 +3646,12 @@ int kafkaCommon::nodeDepth(Node *node)
 
 Node* kafkaCommon::hasParent(Node *node, const TQString &name)
 {
-    node = node->parent;
+    node = node->tqparent;
     while(node)
     {
         if(node->tag->name.lower() == name.lower())
             return node;
-        node = node->parent;
+        node = node->tqparent;
     }
 
     return 0L;
@@ -3673,31 +3673,31 @@ Node* kafkaCommon::hasParent(Node* startNode, Node* endNode, const TQString &nam
     {
         if(node->tag->name.lower() == name.lower())
             return node;
-        node = node->parent;
+        node = node->tqparent;
     }
 
     return 0;
 }
 
-bool kafkaCommon::insertDomNode(DOM::Node node, DOM::Node parent, DOM::Node nextSibling,
+bool kafkaCommon::insertDomNode(DOM::Node node, DOM::Node tqparent, DOM::Node nextSibling,
                                 DOM::Node rootNode)
 {
     if(node.isNull())
         return false;
 
-    if(parent.isNull())
+    if(tqparent.isNull())
     {
         if(rootNode.isNull())
             return false;
-        parent = rootNode;
+        tqparent = rootNode;
     }
     //Andras: avoid exceptions
-    if (!nextSibling.isNull() && nextSibling.parentNode() != parent)
+    if (!nextSibling.isNull() && nextSibling.parentNode() != tqparent)
     {
       kdDebug(25001)<< "kafkaCommon::insertDomNode() - invalid nextSibling!" << endl;
       return false;
     }
-    if (node.ownerDocument() != parent.ownerDocument())
+    if (node.ownerDocument() != tqparent.ownerDocument())
     {
       kdDebug(25001)<< "kafkaCommon::insertDomNode() - ownerDocument is different!" << endl;
       return false;
@@ -3705,7 +3705,7 @@ bool kafkaCommon::insertDomNode(DOM::Node node, DOM::Node parent, DOM::Node next
 
     try
     {
-        parent.insertBefore(node, nextSibling);
+        tqparent.insertBefore(node, nextSibling);
     }
     catch(DOM::DOMException e)
     {
@@ -3716,12 +3716,12 @@ bool kafkaCommon::insertDomNode(DOM::Node node, DOM::Node parent, DOM::Node next
 
 bool kafkaCommon::removeDomNode(DOM::Node node)
 {
-    DOM::Node parent = node.parentNode();
+    DOM::Node tqparent = node.parentNode();
 
-    if(parent.isNull())
+    if(tqparent.isNull())
         return false;
 
-    parent.removeChild(node);
+    tqparent.removeChild(node);
 
     return true;
 }
@@ -3733,7 +3733,7 @@ DOM::Node kafkaCommon::createDomNode(const TQString &nodeName, const DTDStruct*
     //this will change with the futur multi-DTDs support
     //It does not use exceptions handling, so everything is checked via the DTEP definitions.
     DOM::Node dn;
-    QTag *qTag = 0L;
+    TQTag *qTag = 0L;
 
     qTag = QuantaCommon::tagFromDTD(dtd, nodeName);
 
@@ -3766,7 +3766,7 @@ DOM::Node kafkaCommon::createDomNodeAttribute(const TQString &nodeName, const DT
         const TQString &attrName, const TQString &attrValue, DOM::Document rootNode)
 {
     DOM::Node attr;
-    QTag *qTag = 0L;
+    TQTag *qTag = 0L;
 
     qTag = QuantaCommon::tagFromDTD(dtd, nodeName);
     if(!qTag)
@@ -3908,24 +3908,24 @@ bool kafkaCommon::isInline(DOM::Node domNode)
     return isInline(domNode.nodeName().string());
 }
 
-bool kafkaCommon::parentSupports(DOM::Node parent, DOM::Node startNode, DOM::Node endNode,
+bool kafkaCommon::tqparentSupports(DOM::Node tqparent, DOM::Node startNode, DOM::Node endNode,
                                  const DTDStruct* dtd)
 {
-    QTag *parentQTag;
+    TQTag *tqparentTQTag;
     DOM::Node child;
 
-    if(!dtd || parent.isNull())
+    if(!dtd || tqparent.isNull())
         return false;
 
-    parentQTag = QuantaCommon::tagFromDTD(dtd, parent.nodeName().string());
+    tqparentTQTag = QuantaCommon::tagFromDTD(dtd, tqparent.nodeName().string());
 
-    if(!parentQTag)
+    if(!tqparentTQTag)
         return false;
 
     child = startNode;
     while(!child.isNull())
     {
-        if(!parentQTag->isChild(child.nodeName().string()))
+        if(!tqparentTQTag->isChild(child.nodeName().string()))
             return false;
         if(child == endNode)
             return true;
@@ -3974,17 +3974,17 @@ void kafkaCommon::coutDomTree(DOM::Node, int)
         dots.fill('_', indent);
         output = dots;
         if (node.nodeType() != DOM::Node::TEXT_NODE)
-            output += node.nodeName().string().replace('\n'," ");
+            output += node.nodeName().string().tqreplace('\n'," ");
         else
         {
             output += "\"";
-            output+= node.nodeValue().string().replace('\n'," ");
+            output+= node.nodeValue().string().tqreplace('\n'," ");
             output += "\"";
         }
         kdDebug(25001) << output <<" (" << node.nodeType() << ") "<<
         node.handle() <<  endl;
         kdDebug(25001)<< dots << "  +++ prev " << node.previousSibling().handle() << " next " <<
-        node.nextSibling().handle() << " parent " <<
+        node.nextSibling().handle() << " tqparent " <<
         node.parentNode().handle() << " child " << node.firstChild().handle() << endl;
         for(j = 0; j < (int)node.attributes().length(); ++j)
         {
@@ -4016,18 +4016,18 @@ void kafkaCommon::coutTree(Node *node, int indent)
         node->tag->endPos(eLine, eCol);
         if (node->tag->type == Tag::XmlTag || node->tag->type == Tag::XmlTagEnd ||
                 node->tag->type == Tag::ScriptTag)
-            output += node->tag->name.replace('\n',"<return>");
+            output += node->tag->name.tqreplace('\n',"<return>");
         else
         {
             output += "\"";
-            output+= node->tag->tagStr().replace('\n',"<return>");
+            output+= node->tag->tagStr().tqreplace('\n',"<return>");
             output += "\"";
         }
         kdDebug(25001) << output <<" (" << node->tag->type << ", " << node->tag->cleanStrBuilt() << ", " <<
         node->tag->indentationDone() << ") "<< node << " at pos " << bLine << ":" << bCol << " - " <<
         eLine << ":" << eCol << endl;
-        kdDebug(25001)<< dots << "  +++ prev " << node->prev << " next " << node->next << " parent " <<
-        node->parent << " child " << node->child << endl;
+        kdDebug(25001)<< dots << "  +++ prev " << node->prev << " next " << node->next << " tqparent " <<
+        node->tqparent << " child " << node->child << endl;
         for(j = 0; j < node->tag->attrCount(); ++j)
         {
             kdDebug(25001)<< dots << " *** attr" << j << " " <<
@@ -4069,13 +4069,13 @@ int kafkaCommon::isInsideTag(Node* start_node, Node* end_node, TQString const& t
 
     tag_start = hasParent(start_node, tag_name);
     if(tag_start)
-        return 0; // only start_node has tag_name as parent
+        return 0; // only start_node has tag_name as tqparent
 
     tag_start = hasParent(end_node, tag_name);
     if(tag_start)
-        return 0; // only end_node has tag_name as parent
+        return 0; // only end_node has tag_name as tqparent
 
-    return -1; // neither the nodes have tag_name as parent
+    return -1; // neither the nodes have tag_name as tqparent
 }
 
 int kafkaCommon::isInsideTag(Node* start_node, Node* end_node, TQString const& tag_name,
@@ -4092,13 +4092,13 @@ int kafkaCommon::isInsideTag(Node* start_node, Node* end_node, TQString const& t
 
     tag_start = hasParent(start_node, tag_name);
     if(tag_start && tag_start->tag->hasAttribute(attribute_name) && tag_start->tag->attributeValue(attribute_name, true) == attribute_value)
-        return 0; // only start_node has tag_name as parent
+        return 0; // only start_node has tag_name as tqparent
 
     tag_start = hasParent(end_node, tag_name);
     if(tag_start && tag_start->tag->hasAttribute(attribute_name) && tag_start->tag->attributeValue(attribute_name, true) == attribute_value)
-        return 0; // only end_node has tag_name as parent
+        return 0; // only end_node has tag_name as tqparent
 
-    return -1; // neither the nodes have tag_name as parent
+    return -1; // neither the nodes have tag_name as tqparent
 }
 
 bool kafkaCommon::isBetweenWords(Node* node, int offset)