Remove the tq in front of these incorrectly TQt4-converted methods/data members:

tqrepaint[...]
tqinvalidate[...]
tqparent[...]
tqmask[...]
tqlayout[...]
tqalignment[...]


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

11 files changed, 91 insertions, 91 deletions

diff --git a/quanta/parts/kafka/htmldocumentpropertiesui.ui b/quanta/parts/kafka/htmldocumentpropertiesui.ui
index e83d6303..de2293dd 100644
--- a/quanta/parts/kafka/htmldocumentpropertiesui.ui
+++ b/quanta/parts/kafka/htmldocumentpropertiesui.ui
@@ -452,5 +452,5 @@
     <slot access="protected" specifier="pure virtual">CSSChanged(TQListViewItem * )</slot>
     <slot access="protected" specifier="pure virtual">linkChanged( const TQString&amp; )</slot>
 </Q_SLOTS>
-<tqlayoutdefaults spacing="6" margin="11"/>
+<layoutdefaults spacing="6" margin="11"/>
 </UI>
diff --git a/quanta/parts/kafka/htmlenhancer.cpp b/quanta/parts/kafka/htmlenhancer.cpp
index e9419799..b15d3c74 100644
--- a/quanta/parts/kafka/htmlenhancer.cpp
+++ b/quanta/parts/kafka/htmlenhancer.cpp
@@ -47,7 +47,7 @@ HTMLEnhancer::~HTMLEnhancer()
 	delete m_stddirs;
 }
 
-bool HTMLEnhancer::enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node nextDNode)
+bool HTMLEnhancer::enhanceNode(Node *node, DOM::Node parentDNode, DOM::Node nextDNode)
 {
 	DOM::Node domNode, domNode2, attr, *ptDomNode;
 	bool tbody, goUp;
@@ -127,7 +127,7 @@ bool HTMLEnhancer::enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node ne
 	}
     
     TQTag* qTag = QuantaCommon::tagFromDTD(m_wkafkapart->getCurrentDoc()->defaultDTD(),
-                                          tqparentDNode.nodeName().string());
+                                          parentDNode.nodeName().string());
 
 	//THEN tqreplace, if asked, scripts by a little icon.
     if(node->tag->type == Tag::ScriptTag && m_showIconForScripts && qTag->isChild("IMG", false))
@@ -160,7 +160,7 @@ bool HTMLEnhancer::enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node ne
 			kafkaCommon::editDomNodeAttribute(domNode, "img", m_wkafkapart->defaultDTD(),
 				"title", text, m_wkafkapart->getKafkaWidget()->document());
 
-			if(!kafkaCommon::insertDomNode(domNode, tqparentDNode, nextDNode))
+			if(!kafkaCommon::insertDomNode(domNode, parentDNode, nextDNode))
 				return false;
 			m_wkafkapart->connectDomNodeToQuantaNode(domNode, node);
 		}
@@ -196,7 +196,7 @@ bool HTMLEnhancer::enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node ne
             kafkaCommon::editDomNodeAttribute(domNode, "img", m_wkafkapart->defaultDTD(),
                 "title", text, m_wkafkapart->getKafkaWidget()->document());
 
-            if(!kafkaCommon::insertDomNode(domNode, tqparentDNode, nextDNode))
+            if(!kafkaCommon::insertDomNode(domNode, parentDNode, nextDNode))
                 return false;
             m_wkafkapart->connectDomNodeToQuantaNode(domNode, node);
         }
diff --git a/quanta/parts/kafka/htmlenhancer.h b/quanta/parts/kafka/htmlenhancer.h
index 73c62251..065654a4 100644
--- a/quanta/parts/kafka/htmlenhancer.h
+++ b/quanta/parts/kafka/htmlenhancer.h
@@ -47,10 +47,10 @@ public:
 	 * The DOM::Node must be built before calling this
 	 * function.
 	 * @param node The Node we want to enhance.
-	 * @param tqparentDNode the tqparent DOM::Node of the root DOM::Node of node.
+	 * @param parentDNode the tqparent DOM::Node of the root DOM::Node of node.
 	 * @param nextDNode the DOM::Node next to the root DOM::Node of node.
 	 */
-	virtual bool enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node nextDNode);
+	virtual bool enhanceNode(Node *node, DOM::Node parentDNode, DOM::Node nextDNode);
 
 	/**
 	 * This functions is called once the whole DOM::Node tree is built. It will add empty
diff --git a/quanta/parts/kafka/kafkacommon.cpp b/quanta/parts/kafka/kafkacommon.cpp
index 0d15ca02..26aadd51 100644
--- a/quanta/parts/kafka/kafkacommon.cpp
+++ b/quanta/parts/kafka/kafkacommon.cpp
@@ -386,9 +386,9 @@ void kafkaCommon::applyIndentation(Node *node, int nbOfSpaces, int nbOfTabs, Nod
        !node->prev && getNodeDisplay(node->tqparent, true) == kafkaCommon::blockDisplay)
     {
         AreaStruct node_area = node->tag->area();
-        AreaStruct tqparent_area = node->tqparent->tag->area();
+        AreaStruct parent_area = node->tqparent->tag->area();
 
-        if(node_area.bLine == tqparent_area.bLine)
+        if(node_area.bLine == parent_area.bLine)
         {
             node->tag->setIndentationDone(true);
             return;
@@ -969,7 +969,7 @@ Node* kafkaCommon::createMandatoryNodeSubtree(Node *node, Document *doc)
         {
             if(it.data())
             {
-                nodeTQTag = QuantaCommon::tagFromDTD(nodeTQTag->tqparentDTD, it.key());
+                nodeTQTag = QuantaCommon::tagFromDTD(nodeTQTag->parentDTD, it.key());
                 if(!nodeTQTag)
                     return node;
                 currentParent = createAndInsertNode(nodeTQTag->name(), "", Tag::XmlTag, doc,
@@ -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->tqparentNode(),
+            parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
             parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
             child = parentNode->firstChild();
             if(cursorOffset != 0)
             {
@@ -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->tqparentNode(),
+                parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
                 parentNode, parentNode, modifs);*/
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
                 child = parentNode->firstChild();
                 while(child /*&& child == endNode*/ &&
                       (child == endNode || child->hasForChild(endNode)/* ||
@@ -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->tqparentNode(),
+            	parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
             	parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
             child = parentNode->firstChild();
             while(child && child != startNode && !child->hasForChild(startNode))
             {
@@ -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->tqparentNode(),
+            	parentNode->tag->type, parentNode->tag->write(), parentNode->parentNode(),
             	parentNode, parentNode, modifs);*/
             newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
             if(parentNode == commonParentStartChild)
                 commonParentStartChild = newParentNode;
             if(parentNode == commonParentEndChild)
@@ -1986,10 +1986,10 @@ bool kafkaCommon::addNodeRecursively(Node *newNode, Node *leafNode,
                     if (startSelection && endSelection)
                     {
                       /**copyNewNode = duplicateNode(newNode);
-                      insertNode(copyNewNode, startSelection->tqparentNode(), startSelection,
+                      insertNode(copyNewNode, startSelection->parentNode(), startSelection,
                         endSelection->next, modifs);*/
                       copyNewNode = duplicateNodeSubtree(newNode);
-                      insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
+                      insertNodeSubtree(copyNewNode, startSelection->parentNode(), 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->tqparentNode(), startSelection,
+                  insertNode(copyNewNode, startSelection->parentNode(), startSelection,
                     endSelection->next, modifs);*/
                   copyNewNode = duplicateNodeSubtree(newNode);
-                  insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
+                  insertNodeSubtree(copyNewNode, startSelection->parentNode(), 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->tqparentNode(), startSelection,
+            insertNode(copyNewNode, startSelection->parentNode(), startSelection,
             	endSelection->next, modifs);*/
             copyNewNode = duplicateNodeSubtree(newNode);
-            insertNodeSubtree(copyNewNode, startSelection->tqparentNode(), startSelection,
+            insertNodeSubtree(copyNewNode, startSelection->parentNode(), startSelection,
                               endSelection->next, modifs);
             nodeInserted = true;
         }
@@ -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)
 {
-    TQTag *nodeNameTQTag, *tqparentTQTag;
+    TQTag *nodeNameTQTag, *parentTQTag;
     Node *node, *lastNodeNameStartNode, *lastNodeNameEndNode;
     Node *parentNode, *newParentNode, *child, *next;
     bool goUp, nodesRemoved = false, DTDError = false, result;
@@ -2672,7 +2672,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
         return kafkaCommon::extractionBadParameters;
 
     //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.
+    //startNode/endNode's inline parents 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;
@@ -2730,7 +2730,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
             if(node != parentNode->firstChild())
             {
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
                 child = parentNode->firstChild();
                 while(child && child != startNode && !child->hasForChild(startNode))
                 {
@@ -2752,7 +2752,7 @@ int kafkaCommon::DTDExtractNode(const TQString &nodeName, Document *doc, Node *s
             if(node != parentNode->SLastChild())
             {
                 newParentNode = duplicateNode(parentNode);
-                insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+                insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
                 if(parentNode == lastNodeNameStartNode)
                     lastNodeNameStartNode = newParentNode;
                 child = parentNode->firstChild();
@@ -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())
         {
-            tqparentTQTag = QuantaCommon::tagFromDTD(node->tqparent);
-            if(tqparentTQTag)
+            parentTQTag = QuantaCommon::tagFromDTD(node->tqparent);
+            if(parentTQTag)
             {
                 child = node->firstChild();
                 while(child)
                 {
-                    if(!tqparentTQTag->isChild(child))
+                    if(!parentTQTag->isChild(child))
                         DTDError = true;
                     child = child->next;
                 }
@@ -2951,7 +2951,7 @@ void kafkaCommon::splitStartNodeSubtree(Node* startNode, Node* commonParent,
         if(node != parentNode->firstChild())
         {
             Node* newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
             Node* child = parentNode->firstChild();
             while(child && child != startNode && !child->hasForChild(startNode))
             {
@@ -2989,7 +2989,7 @@ void kafkaCommon::splitEndNodeSubtree(Node* endNode, Node* commonParent,
         if(node != parentNode->lastChild())
         {
             Node* newParentNode = duplicateNode(parentNode);
-            insertNode(newParentNode, parentNode->tqparentNode(), parentNode, parentNode, modifs);
+            insertNode(newParentNode, parentNode->parentNode(), parentNode, parentNode, modifs);
             if(parentNode == commonParentStartChild)
                 commonParentStartChild = newParentNode;
             if(parentNode == commonParentEndChild)
@@ -3908,24 +3908,24 @@ bool kafkaCommon::isInline(DOM::Node domNode)
     return isInline(domNode.nodeName().string());
 }
 
-bool kafkaCommon::tqparentSupports(DOM::Node tqparent, DOM::Node startNode, DOM::Node endNode,
+bool kafkaCommon::parentSupports(DOM::Node tqparent, DOM::Node startNode, DOM::Node endNode,
                                  const DTDStruct* dtd)
 {
-    TQTag *tqparentTQTag;
+    TQTag *parentTQTag;
     DOM::Node child;
 
     if(!dtd || tqparent.isNull())
         return false;
 
-    tqparentTQTag = QuantaCommon::tagFromDTD(dtd, tqparent.nodeName().string());
+    parentTQTag = QuantaCommon::tagFromDTD(dtd, tqparent.nodeName().string());
 
-    if(!tqparentTQTag)
+    if(!parentTQTag)
         return false;
 
     child = startNode;
     while(!child.isNull())
     {
-        if(!tqparentTQTag->isChild(child.nodeName().string()))
+        if(!parentTQTag->isChild(child.nodeName().string()))
             return false;
         if(child == endNode)
             return true;
diff --git a/quanta/parts/kafka/kafkacommon.h b/quanta/parts/kafka/kafkacommon.h
index 0a1d25bd..fdec2aef 100644
--- a/quanta/parts/kafka/kafkacommon.h
+++ b/quanta/parts/kafka/kafkacommon.h
@@ -290,19 +290,19 @@ public:
 	 * WARNING : baseNode is used as the rootNode.
 	 * It will also try to merge text/Empty Nodes.
 	 * @param node The node to insert.
-	 * @param tqparentNode This Node will be the tqparent of node.
+	 * @param parentNode This Node will be the tqparent of node.
 	 * @param nextSibling This Node will be the next Sibling of Node. If null, node will be appended at
-	 * the child list of tqparentNode.
+	 * the child list of parentNode.
 	 * TODO: @param rootNode The rootNode of the tree we want to insert the Node (usually &baseNode).
 	 * @param modifs The changes made are logged into modifs. Put 0L if you don't want to log
 	 * and if you know what you're doing!
 	 * @param merge Try to merge with the siblings if possible.
 	 * @return Returns a pointer to the node inserted.
 	 */
-	static Node* insertNode(Node *node, Node* tqparentNode, Node* nextSibling,
+	static Node* insertNode(Node *node, Node* parentNode, Node* nextSibling,
                             NodeModifsSet *modifs/**, Node **rootNode*/, bool merge = true);
 
-    static Node* insertNode(Node *node, Node* tqparentNode, Node* nextSibling, NodeSelection& selection, 
+    static Node* insertNode(Node *node, Node* parentNode, Node* nextSibling, NodeSelection& selection, 
                             NodeModifsSet *modifs, bool merge = true);
  
 	/**
@@ -373,15 +373,15 @@ public:
 	 * WARNING : baseNode is used as the rootNode.
 	 * It will also try to merge text/Empty Nodes.
 	 * @param node The root node of the Node subtree to insert.
-	 * @param tqparentNode This Node will be the tqparent of node.
+	 * @param parentNode This Node will be the tqparent of node.
 	 * @param nextSibling This Node will be the next Sibling of Node. If null, node will be appended at
-	 * the child list of tqparentNode.
+	 * the child list of parentNode.
 	 * @param modifs The changes made are logged into modifs. Put 0L if you don't want to log
 	 * and if you know what you're doing!
 	 * @param merge Try to merge with the siblings if possible.
 	 * @return Returns a pointer to the node inserted.
 	 */
-	static Node* insertNodeSubtree(Node *node, Node* tqparentNode, Node* nextSibling,
+	static Node* insertNodeSubtree(Node *node, Node* parentNode, Node* nextSibling,
 		NodeModifsSet *modifs, bool merge = true);
 
 	/**
@@ -401,7 +401,7 @@ public:
 	 * @param modifs The changes made are logged into modifs.
 	 * @return Returns a pointer to the node inserted.
 	 */
-	static Node* insertNodeSubtree(Node *node, Node* tqparentNode, Node* nextSibling,
+	static Node* insertNodeSubtree(Node *node, Node* parentNode, Node* nextSibling,
                                    Node* nextEndSibling, NodeModifsSet *modifs, bool merge = true);
 
 	/**
@@ -414,7 +414,7 @@ public:
     static Node* DTDInsertNodeSubtree(Node *node, NodeSelectionInd& selection, 
                                       Node **cursorNode, long& cursorOffset, NodeModifsSet *modifs);
 	
-    static Node* DTDInsertNodeSubtree(Node* newNode, Node* tqparentNode, Node* nextSibling, 
+    static Node* DTDInsertNodeSubtree(Node* newNode, Node* parentNode, Node* nextSibling, 
                                       NodeSelection& cursorHolder, NodeModifsSet *modifs);
     
     /**
@@ -544,7 +544,7 @@ public:
     
     /**
      * Extract a node subtree in the tree. WARNING This function will log that the nodes were added.
-     * This funtion not only extract the start node but also will extract inline tqparents.
+     * This funtion not only extract the start node but also will extract inline parents.
      * @param startNode The node from which we start the removal.
      * @param startOffset The offset of startNode from which we start the removal.
      * @param endNode The node from which we end the removal.
@@ -576,7 +576,7 @@ public:
      * Get a node subtree from the tree. It is similar to extractNodeSubtree() 
      * but it doesn't extract anything. 
      * It's useful to get a copy of the Node subtree from a selection, for example.
-     * This funtion not only extract the start node but also will extract inline tqparents.
+     * This funtion not only extract the start node but also will extract inline parents.
      * @param startNode The starting Node.
      * @param startOffset If firstNode is a text, specify at which offset the new start Node will be splitted.
      * @param endNode The ending Node.
@@ -630,7 +630,7 @@ public:
 	 * @param nodeToMove The node to move :-)
 	 * @param newParent The new tqparent of nodeToMove.
      * @param newNextSibling The new next Sibling of nodeToMove. If null, node will be appended at
-     * the child list of tqparentNode.
+     * the child list of parentNode.
 	 * @param modifs The changes made are logged into modifs.
 	 * @param merge Specifies if it should try to merge the Node at its new location.
 	 */
@@ -855,7 +855,7 @@ public:
 	/**
 	 * Get the node's depth in the tree.
 	 * @param node The node we want the depth.
-	 * @return Returns the depth of node. It is basically the number of tqparents of node.
+	 * @return Returns the depth of node. It is basically the number of parents of node.
 	 * It will return 0 if node has no tqparent Nodes, and -1 if node doesn't exists.
 	 */
 	static int nodeDepth(Node *node);
@@ -991,12 +991,12 @@ public:
 	static int childPosition(DOM::Node domNode);
 
 	/**
-	 * Returns the position'th child of tqparentNode.
-	 * @param tqparentNode The tqparent Node of the node to return.
+	 * Returns the position'th child of parentNode.
+	 * @param parentNode The tqparent Node of the node to return.
 	 * @param position We return the position'th child Node.
 	 * @param fallback If set to true, it will always return a valid Node (except if there is no child!!)
 	 */
-	static DOM::Node getChildNode(DOM::Node tqparentNode, int position, bool fallback = false);
+	static DOM::Node getChildNode(DOM::Node parentNode, int position, bool fallback = false);
 
 	/**
 	 * Specify if a DOM::Node is inline (as specified in isInline()) or text.
@@ -1008,7 +1008,7 @@ public:
 	 * Specify if tqparent supports the siblings DOM::Nodes starting from startNode to endNode
 	 * according to the DTD dtd.
 	 */
-	static bool tqparentSupports(DOM::Node tqparent, DOM::Node startNode, DOM::Node endNode,
+	static bool parentSupports(DOM::Node tqparent, DOM::Node startNode, DOM::Node endNode,
 		const DTDStruct* dtd);
     
 
diff --git a/quanta/parts/kafka/kafkahtmlpart.cpp b/quanta/parts/kafka/kafkahtmlpart.cpp
index 4dfe3f7d..ed31f049 100644
--- a/quanta/parts/kafka/kafkahtmlpart.cpp
+++ b/quanta/parts/kafka/kafkahtmlpart.cpp
@@ -1034,12 +1034,12 @@ void KafkaWidget::keyDelete()
             }
             else if(isParent && !nextIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(toplevelBlock, startNode2, endNode2,
+                if(kafkaCommon::parentSupports(toplevelBlock, startNode2, endNode2,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(toplevelBlock, startNode2, endNode2, DOM::Node(), false);
                 else
                 {
-                    if(kafkaCommon::tqparentSupports(commonParent, startNode, endNode,
+                    if(kafkaCommon::parentSupports(commonParent, startNode, endNode,
                                                    w->getCurrentDoc()->defaultDTD()))
                         moveDomNodes(commonParent, startNode, endNode, childOfCommonParent2,
                                      true);
@@ -1051,13 +1051,13 @@ void KafkaWidget::keyDelete()
             }
             else if(isParent && nextIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(toplevelBlock, startNode2, endNode2,
+                if(kafkaCommon::parentSupports(toplevelBlock, startNode2, endNode2,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(toplevelBlock, startNode2, endNode2, DOM::Node(), false);
                 else
                 {
-                    if(kafkaCommon::tqparentSupports(commonParent, startNode, endNode,
-                                                   w->getCurrentDoc()->defaultDTD()) && kafkaCommon::tqparentSupports(
+                    if(kafkaCommon::parentSupports(commonParent, startNode, endNode,
+                                                   w->getCurrentDoc()->defaultDTD()) && kafkaCommon::parentSupports(
                                 commonParent, startNode2, endNode2, w->getCurrentDoc()->defaultDTD()))
                     {
                         moveDomNodes(commonParent, startNode, endNode, childOfCommonParent,
@@ -1073,7 +1073,7 @@ void KafkaWidget::keyDelete()
             }
             else if(!isParent && nextIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(commonParent, startNode2, endNode2,
+                if(kafkaCommon::parentSupports(commonParent, startNode2, endNode2,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(commonParent, startNode2, endNode2, childOfCommonParent2, true);
                 else
@@ -1460,13 +1460,13 @@ void KafkaWidget::keyBackspace()
             }
             else if(isParent && !prevIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(toplevelBlock2, startNode, endNode,
+                if(kafkaCommon::parentSupports(toplevelBlock2, startNode, endNode,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(toplevelBlock2, startNode, endNode, toplevelBlock2.firstChild(),
                                  true);
                 else
                 {
-                    if(kafkaCommon::tqparentSupports(commonParent, startNode2, endNode2,
+                    if(kafkaCommon::parentSupports(commonParent, startNode2, endNode2,
                                                    w->getCurrentDoc()->defaultDTD()))
                         moveDomNodes(commonParent, startNode2, endNode2,
                                      childOfCommonParent2, true);
@@ -1478,14 +1478,14 @@ void KafkaWidget::keyBackspace()
             }
             else if(isParent && prevIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(toplevelBlock2, startNode, endNode,
+                if(kafkaCommon::parentSupports(toplevelBlock2, startNode, endNode,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(toplevelBlock2, startNode, endNode, toplevelBlock2.firstChild(),
                                  true);
                 else
                 {
-                    if(kafkaCommon::tqparentSupports(commonParent, startNode, endNode,
-                                                   w->getCurrentDoc()->defaultDTD()) && kafkaCommon::tqparentSupports(
+                    if(kafkaCommon::parentSupports(commonParent, startNode, endNode,
+                                                   w->getCurrentDoc()->defaultDTD()) && kafkaCommon::parentSupports(
                                 commonParent, startNode2, endNode2, w->getCurrentDoc()->defaultDTD()))
                     {
                         moveDomNodes(commonParent, startNode, endNode, childOfCommonParent,
@@ -1501,7 +1501,7 @@ void KafkaWidget::keyBackspace()
             }
             else if(!isParent && prevIsBlock)
             {
-                if(kafkaCommon::tqparentSupports(commonParent, startNode, endNode,
+                if(kafkaCommon::parentSupports(commonParent, startNode, endNode,
                                                w->getCurrentDoc()->defaultDTD()))
                     moveDomNodes(commonParent, startNode, endNode, childOfCommonParent, false);
                 else
diff --git a/quanta/parts/kafka/kafkahtmlpart.h b/quanta/parts/kafka/kafkahtmlpart.h
index 9365f925..c0c1012f 100644
--- a/quanta/parts/kafka/kafkahtmlpart.h
+++ b/quanta/parts/kafka/kafkahtmlpart.h
@@ -114,7 +114,7 @@ public:
 
     /**
      * It will move DOM::Nodes from startNode to endNode as tqchildren of newParent. It does NOT check
-     * if the move is valid, so it may crash. Please check before with kafkaCommon::tqparentSupports().
+     * if the move is valid, so it may crash. Please check before with kafkaCommon::parentSupports().
      * @param newParent The new tqparent of the DOM::Nodes.
      * @param startNode The first node to move.
      * @param endNode Starting from endNode, the last sibling to move.
diff --git a/quanta/parts/kafka/kafkasyncoptionsui.ui b/quanta/parts/kafka/kafkasyncoptionsui.ui
index 54d7d5d0..509ab551 100644
--- a/quanta/parts/kafka/kafkasyncoptionsui.ui
+++ b/quanta/parts/kafka/kafkasyncoptionsui.ui
@@ -192,5 +192,5 @@
         </widget>
     </grid>
 </widget>
-<tqlayoutdefaults spacing="6" margin="11"/>
+<layoutdefaults spacing="6" margin="11"/>
 </UI>
diff --git a/quanta/parts/kafka/nodeenhancer.h b/quanta/parts/kafka/nodeenhancer.h
index 22737082..6e8bc44c 100644
--- a/quanta/parts/kafka/nodeenhancer.h
+++ b/quanta/parts/kafka/nodeenhancer.h
@@ -45,10 +45,10 @@ public:
 	 * The DOM::Node must be built before calling this
 	 * function.
 	 * @param node The Node we want to enhance.
-	 * @param tqparentDNode the tqparent DOM::Node of the root DOM::Node of node.
+	 * @param parentDNode the tqparent DOM::Node of the root DOM::Node of node.
 	 * @param nextDNode the DOM::Node next to the root DOM::Node of node.
 	 */
-	virtual bool enhanceNode(Node *node, DOM::Node tqparentDNode, DOM::Node nextDNode) = 0;
+	virtual bool enhanceNode(Node *node, DOM::Node parentDNode, DOM::Node nextDNode) = 0;
 
 	/**
 	 * This function apply some modifications once the whole DOM::Node tree is built.
diff --git a/quanta/parts/kafka/undoredo.cpp b/quanta/parts/kafka/undoredo.cpp
index 8eb6cfbe..85f23398 100644
--- a/quanta/parts/kafka/undoredo.cpp
+++ b/quanta/parts/kafka/undoredo.cpp
@@ -703,10 +703,10 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                                   {
                                           //try
                                           //{
-                                                  dn = n->_rootNode.tqparentNode().removeChild(n->_rootNode);
+                                                  dn = n->_rootNode.parentNode().removeChild(n->_rootNode);
                                           //} catch(DOM::DOMException e) {kafkaSyncError();}
                                           //try{
-                                                  domNode.tqparentNode().insertBefore(dn, domNode);
+                                                  domNode.parentNode().insertBefore(dn, domNode);
                                           //} catch(DOM::DOMException e) {}
                                   }
                                   else if(n->tag->type == Tag::XmlTag || n->tag->type == Tag::Text)
@@ -733,7 +733,7 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                           }
                   }
                   //try{
-                          domNode.tqparentNode().removeChild(domNode);
+                          domNode.parentNode().removeChild(domNode);
                   //} catch(DOM::DOMException e) {kafkaSyncError();}
           }
           else if(_node->tag->type == Tag::XmlTagEnd && _node->closesPrevious &&
@@ -764,9 +764,9 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                                   {
                                           kafkaInterface->disconnectDomNodeFromQuantaNode(dm);
                                           //try{
-                                                  dm.tqparentNode().removeChild(dm);
+                                                  dm.parentNode().removeChild(dm);
                                           //} catch(DOM::DOMException e) {kafkaSyncError();}
-                                          dm = kafkaCommon::getNextDomNode(dm, goUp, false, domNode.tqparentNode());
+                                          dm = kafkaCommon::getNextDomNode(dm, goUp, false, domNode.parentNode());
                                   }
                           }
                           else
@@ -775,7 +775,7 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                                   while(!domNode.nextSibling().isNull())
                                   {
                                           //try{
-                                                  dn = domNode.tqparentNode().removeChild(domNode.nextSibling());
+                                                  dn = domNode.parentNode().removeChild(domNode.nextSibling());
                                           //} catch(DOM::DOMException e) {kafkaSyncError();}
                                           //try{
                                                   domNode2.appendChild(dn);
@@ -788,7 +788,7 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                           while(!domNode.nextSibling().isNull())
                           {
                                   //try{
-                                          dn = domNode.tqparentNode().removeChild(domNode.nextSibling());
+                                          dn = domNode.parentNode().removeChild(domNode.nextSibling());
                                   //} catch(DOM::DOMException e) {kafkaSyncError();}
                                   //try{
                                           domNode2.appendChild(dn);
@@ -810,7 +810,7 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                   return true;//no kafka node here, due to an invalid pos.
           domNode = _node->_rootNode;
           //try{
-                  domNode.tqparentNode().removeChild(domNode);
+                  domNode.parentNode().removeChild(domNode);
           //} catch(DOM::DOMException e) {kafkaSyncError();}
           kafkaInterface->disconnectDomNodeFromQuantaNode(domNode);
           kafkaInterface->buildKafkaNodeFromNode(_node);
@@ -837,7 +837,7 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                                   if(!n->_rootNode.isNull())
                                   {
                                           //try{
-                                                  dn = n->_rootNode.tqparentNode().removeChild(n->_rootNode);
+                                                  dn = n->_rootNode.parentNode().removeChild(n->_rootNode);
                                           //} catch(DOM::DOMException e) {kafkaSyncError();}
                                           //try{
                                                   domNode.appendChild(dn);
@@ -857,10 +857,10 @@ bool undoRedo::undoNodeModifInKafka(NodeModif */**_nodeModif*/)
                           if(!n->_rootNode.isNull())
                           {
                                   //try{
-                                          dn = n->_rootNode.tqparentNode().removeChild(n->_rootNode);
+                                          dn = n->_rootNode.parentNode().removeChild(n->_rootNode);
                                   //} catch(DOM::DOMException e) {kafkaSyncError();}
                                   //try{
-                                          domNode.tqparentNode().appendChild(dn);
+                                          domNode.parentNode().appendChild(dn);
                                   //} catch(DOM::DOMException e) {}
                           }
                           else if(n->tag->type == Tag::XmlTag || n->tag->type == Tag::Text)
diff --git a/quanta/parts/kafka/wkafkapart.cpp b/quanta/parts/kafka/wkafkapart.cpp
index 6eae1afc..91c32106 100644
--- a/quanta/parts/kafka/wkafkapart.cpp
+++ b/quanta/parts/kafka/wkafkapart.cpp
@@ -526,9 +526,9 @@ bool KafkaDocument::buildKafkaNodeFromNode(Node *node, bool insertNode)
         else
             canInsertEmptyNode = kafkaCommon::hasParent(node, "body");
 
-        Node* tqparent_node = node->tqparent;
-        TQTag* tqparent_node_description_tag = QuantaCommon::tagFromDTD(tqparent_node);
-        if(tqparent_node_description_tag && !tqparent_node_description_tag->isChild(node, false, true))
+        Node* parent_node = node->tqparent;
+        TQTag* parent_node_description_tag = QuantaCommon::tagFromDTD(parent_node);
+        if(parent_node_description_tag && !parent_node_description_tag->isChild(node, false, true))
             canInsertEmptyNode = false;
     }
 
@@ -1930,7 +1930,7 @@ void KafkaDocument::slotDomNodeModified(DOM::Node domNode, NodeModifsSet* modifs
 	Node *node = 0L;
 	NodeModif *modif;
 	kNodeAttrs *props, *newProps;
-	DOM::Node newDomNode, tqparentDomNode, nextSiblingDomNode;
+	DOM::Node newDomNode, parentDomNode, nextSiblingDomNode;
 	DOM::Node *ptDomNode;
 	TQTag *qTag;
 
@@ -1985,7 +1985,7 @@ void KafkaDocument::slotDomNodeModified(DOM::Node domNode, NodeModifsSet* modifs
 			//let's create the corresponding Text Node and the P tag only if necessary
 			modifs = new NodeModifsSet();
 			modif = new NodeModif();
-			tqparentDomNode = domNode.parentNode();
+			parentDomNode = domNode.parentNode();
 			nextSiblingDomNode = domNode.nextSibling();
 
 			if(!qTag->isChild("#text", false))
@@ -1993,7 +1993,7 @@ void KafkaDocument::slotDomNodeModified(DOM::Node domNode, NodeModifsSet* modifs
 				newDomNode = kafkaCommon::createDomNode("p",
 					getNode(domNode.parentNode())->tag->dtd(), m_kafkaPart->document());
 				kafkaCommon::removeDomNode(domNode);
-				kafkaCommon::insertDomNode(newDomNode, tqparentDomNode, nextSiblingDomNode);
+				kafkaCommon::insertDomNode(newDomNode, parentDomNode, nextSiblingDomNode);
 				kafkaCommon::insertDomNode(domNode, newDomNode);
 
 				node = kafkaCommon::createNode("p", "", Tag::XmlTag, m_currentDoc);
@@ -2002,12 +2002,12 @@ void KafkaDocument::slotDomNodeModified(DOM::Node domNode, NodeModifsSet* modifs
 				node->setRootNode(ptDomNode);
 				ptDomNode = new DOM::Node(newDomNode);
 				node->setLeafNode(ptDomNode);
-				node = kafkaCommon::insertNode(node, getNode(tqparentDomNode),
+				node = kafkaCommon::insertNode(node, getNode(parentDomNode),
 					getNode(nextSiblingDomNode), getNode(nextSiblingDomNode), modifs);
 				newProps->setNode(node);
 				modifs->addNodeModif(modif);
 
-				tqparentDomNode = newDomNode;
+				parentDomNode = newDomNode;
 				nextSiblingDomNode = DOM::Node();
 				modif = new NodeModif();
 			}
@@ -2019,7 +2019,7 @@ void KafkaDocument::slotDomNodeModified(DOM::Node domNode, NodeModifsSet* modifs
 			ptDomNode = new DOM::Node(domNode);
 			node->setLeafNode(ptDomNode);
 			//avoid the merging of Text Nodes
-			node = kafkaCommon::insertNode(node, getNode(tqparentDomNode),
+			node = kafkaCommon::insertNode(node, getNode(parentDomNode),
 				getNode(nextSiblingDomNode), modifs, false);
 			props->setNode(node);
 			modifs->addNodeModif(modif);