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

1 files changed, 31 insertions, 31 deletions

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;