TQt4 port kdevelop

This enables compilation under both Qt3 and Qt4


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

1 files changed, 106 insertions, 106 deletions

diff --git a/languages/cpp/debugger/variablewidget.cpp b/languages/cpp/debugger/variablewidget.cpp
index 163c2024..c5293c8c 100644
--- a/languages/cpp/debugger/variablewidget.cpp
+++ b/languages/cpp/debugger/variablewidget.cpp
@@ -47,14 +47,14 @@
 
 /** The variables widget is passive, and is invoked by the rest of the
     code via two main slots:
-    - slotDbgStatus
+    - slotDbgtqStatus
     - slotCurrentFrame
 
     The first is received the program status changes and the second is
     recieved after current frame in the debugger can possibly changes.
 
     The widget has a list item for each frame/thread combination, with
-    variables as children. However, at each moment only one item is shown.
+    variables as tqchildren. However, at each moment only one item is shown.
     When handling the slotCurrentFrame, we check if variables for the
     current frame are available. If yes, we simply show the corresponding item.
     Otherwise, we fetch the new data from debugger.
@@ -77,8 +77,8 @@ namespace GDBDebugger
 
 VariableWidget::VariableWidget(GDBController*  controller,
                                GDBBreakpointWidget* breakpointWidget,
-                               TQWidget *parent, const char *name)
-: TQWidget(parent, name)
+                               TQWidget *tqparent, const char *name)
+: TQWidget(tqparent, name)
 {
     setIcon(SmallIcon("math_brace"));
     setCaption(i18n("Variable Tree"));
@@ -197,11 +197,11 @@ void VariableWidget::focusInEvent(TQFocusEvent */*e*/)
 // **************************************************************************
 // **************************************************************************
 
-VariableTree::VariableTree(VariableWidget *parent,
+VariableTree::VariableTree(VariableWidget *tqparent,
                            GDBController*  controller,
                            GDBBreakpointWidget* breakpointWidget,
                            const char *name)
-    : KListView(parent, name),
+    : KListView(tqparent, name),
       TQToolTip( viewport() ),
       controller_(controller),
       breakpointWidget_(breakpointWidget),
@@ -244,7 +244,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
 
     setSelected(item, true);    // Need to select this item.
 
-    if (item->parent())
+    if (item->tqparent())
     {
         KPopupMenu popup(this);
         KPopupMenu format(this);
@@ -271,19 +271,19 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
             format.setCheckable(true);
             idNatural = format.insertItem(i18n("Natural"),
                                           (int)VarItem::natural);
-            format.setAccel(Qt::Key_N, idNatural);
+            format.setAccel(TQt::Key_N, idNatural);
             idHex = format.insertItem(i18n("Hexadecimal"),
                                       (int)VarItem::hexadecimal);
-            format.setAccel(Qt::Key_X, idHex);
+            format.setAccel(TQt::Key_X, idHex);
             idDecimal = format.insertItem(i18n("Decimal"),
                                           (int)VarItem::decimal);
-            format.setAccel(Qt::Key_D, idDecimal);
+            format.setAccel(TQt::Key_D, idDecimal);
             idCharacter = format.insertItem(i18n("Character"),
                                           (int)VarItem::character);
-            format.setAccel(Qt::Key_C, idCharacter);
+            format.setAccel(TQt::Key_C, idCharacter);
             idBinary = format.insertItem(i18n("Binary"),
                                          (int)VarItem::binary);
-            format.setAccel(Qt::Key_T, idBinary);
+            format.setAccel(TQt::Key_T, idBinary);
 
 
             format.setItemChecked((int)(var->format()), true);
@@ -305,7 +305,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
         if (dynamic_cast<WatchRoot*>(root)) {
             idRemove = popup.insertItem(
                 SmallIcon("editdelete"), i18n("Remove Watch Variable") );
-            popup.setAccel(Qt::Key_Delete, idRemove);
+            popup.setAccel(TQt::Key_Delete, idRemove);
         } else if (root != recentExpressions_) {
             idWatch = popup.insertItem(
                 i18n("Watch Variable"));
@@ -317,7 +317,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
             MAYBE_DISABLE(idReevaluate);
             idRemove = popup.insertItem(
                 SmallIcon("editdelete"), i18n("Remove Expression") );
-            popup.setAccel(Qt::Key_Delete, idRemove);
+            popup.setAccel(TQt::Key_Delete, idRemove);
         }
 
         if (var)
@@ -328,7 +328,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
 
         int     idCopyToClipboard = popup.insertItem(
             SmallIcon("editcopy"), i18n("Copy Value") );
-        popup.setAccel(Qt::CTRL + Qt::Key_C, idCopyToClipboard);
+        popup.setAccel(TQt::CTRL + TQt::Key_C, idCopyToClipboard);
 
         activePopup_ = &popup;
         /* This code can be executed when debugger is stopped,
@@ -338,7 +338,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
             controller_->addCommand(
                 new GDBCommand(
                     TQString("-data-evaluate-expression &%1")
-                    .arg(var->gdbExpression()),
+                    .tqarg(var->gdbExpression()),
                     this,
                     &VariableTree::handleAddressComputed,
                     true /*handles error*/));
@@ -360,7 +360,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
         {
             if (VarItem *item = dynamic_cast<VarItem*>(currentItem()))
             {
-                ((VariableWidget*)parent())->
+                ((VariableWidget*)tqparent())->
                     slotEvaluateExpression(item->gdbExpression());
             }
         }
@@ -368,7 +368,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
         {
             if (VarItem *item = dynamic_cast<VarItem*>(currentItem()))
             {
-                ((VariableWidget*)parent())->
+                ((VariableWidget*)tqparent())->
                     slotAddWatchVariable(item->gdbExpression());
             }
         }
@@ -505,8 +505,8 @@ void VariableTree::updateCurrentFrame()
 
     controller_->addCommand(
         new GDBCommand(TQString("-stack-list-arguments 0 %1 %2")
-                       .arg(controller_->currentFrame())
-                       .arg(controller_->currentFrame())
+                       .tqarg(controller_->currentFrame())
+                       .tqarg(controller_->currentFrame())
                        .ascii(),
                        this,
                        &VariableTree::argumentsReady));
@@ -547,8 +547,8 @@ void VariableTree::slotEvaluateExpression(const TQString &expression)
 
 TQListViewItem *VariableTree::findRoot(TQListViewItem *item) const
 {
-    while (item->parent())
-        item = item->parent();
+    while (item->tqparent())
+        item = item->tqparent();
 
     return item;
 }
@@ -607,7 +607,7 @@ void VariableTree::maybeTip(const TQPoint &p)
     VarItem * item = dynamic_cast<VarItem*>( itemAt( p ) );
     if ( item )
     {
-        TQRect r = itemRect( item );
+        TQRect r = tqitemRect( item );
         if ( r.isValid() )
             tip( r, item->tipText() );
     }
@@ -711,7 +711,7 @@ void VariableTree::frameIdReady(const TQValueVector<TQString>& lines)
         frame_info += lines[i];
 
     kdDebug(9012) << "frame info: " << frame_info << "\n";
-    frame_info.replace('\n', "");
+    frame_info.tqreplace('\n', "");
 
     static TQRegExp frame_base_rx("frame at 0x([0-9a-fA-F]*)");
     static TQRegExp frame_code_rx("saved [a-zA-Z0-9]* 0x([0-9a-fA-F]*)");
@@ -882,8 +882,8 @@ void VarItem::handleCliPrint(const TQValueVector<TQString>& lines)
         {
             controller_->addCommand(
                 new GDBCommand(TQString("-var-create %1 * \"%2\"")
-                               .arg(varobjName_)
-                               .arg(r.cap(1)),
+                               .tqarg(varobjName_)
+                               .tqarg(r.cap(1)),
                                this,
                                &VarItem::varobjCreated,
                                // On initial create, errors get reported
@@ -968,7 +968,7 @@ void VariableTree::keyPressEvent(TQKeyEvent* e)
                 item->formatFromGdbModifier(text[0].latin1()));
         }
 
-        if (e->key() == Qt::Key_Delete)
+        if (e->key() == TQt::Key_Delete)
         {
             TQListViewItem* root = findRoot(item);
 
@@ -978,7 +978,7 @@ void VariableTree::keyPressEvent(TQKeyEvent* e)
             }
         }
 
-        if (e->key() == Qt::Key_C && e->state() == Qt::ControlButton)
+        if (e->key() == TQt::Key_C && e->state() == TQt::ControlButton)
         {
             copyToClipboard(item);
         }
@@ -988,10 +988,10 @@ void VariableTree::keyPressEvent(TQKeyEvent* e)
 
 void VariableTree::copyToClipboard(TQListViewItem* item)
 {
-    QClipboard *qb = KApplication::clipboard();
+    TQClipboard *qb = KApplication::tqclipboard();
     TQString text = item->text( 1 );
 
-    qb->setText( text, QClipboard::Clipboard );
+    qb->setText( text, TQClipboard::Clipboard );
 }
 
 void VariableTree::handleAddressComputed(const GDBMI::ResultRecord& r)
@@ -1018,15 +1018,15 @@ void VariableTree::handleAddressComputed(const GDBMI::ResultRecord& r)
 // **************************************************************************
 // **************************************************************************
 
-TrimmableItem::TrimmableItem(VariableTree *parent)
-    : KListViewItem (parent, parent->lastChild())
+TrimmableItem::TrimmableItem(VariableTree *tqparent)
+    : KListViewItem (tqparent, tqparent->lastChild())
 {
 }
 
 // **************************************************************************
 
-TrimmableItem::TrimmableItem(TrimmableItem *parent)
-    : KListViewItem (parent, parent->lastChild())
+TrimmableItem::TrimmableItem(TrimmableItem *tqparent)
+    : KListViewItem (tqparent, tqparent->lastChild())
 {
 }
 
@@ -1044,7 +1044,7 @@ void TrimmableItem::paintCell(TQPainter *p, const TQColorGroup &cg,
     if ( !p )
         return;
     // make toplevel item (watch and frame items) names bold
-    if (column == 0 && !parent())
+    if (column == 0 && !tqparent())
     {
         TQFont f = p->font();
         f.setBold(true);
@@ -1069,16 +1069,16 @@ TQListViewItem *TrimmableItem::lastChild() const
 
 int VarItem::varobjIndex = 0;
 
-VarItem::VarItem(TrimmableItem *parent,
+VarItem::VarItem(TrimmableItem *tqparent,
                  const TQString& expression,
                  bool frozen)
-    : TrimmableItem (parent),
+    : TrimmableItem (tqparent),
       expression_(expression),
       highlight_(false),
       oldSpecialRepresentationSet_(false),
       format_(natural),
       numChildren_(0),
-      childrenFetched_(false),
+      tqchildrenFetched_(false),
       updateUnconditionally_(false),
       frozen_(frozen),
       initialCreation_(true),
@@ -1116,14 +1116,14 @@ VarItem::VarItem(TrimmableItem *parent,
     createVarobj();
 }
 
-VarItem::VarItem(TrimmableItem *parent, const GDBMI::Value& varobj,
+VarItem::VarItem(TrimmableItem *tqparent, const GDBMI::Value& varobj,
                  format_t format, bool baseClassMember)
-: TrimmableItem (parent),
+: TrimmableItem (tqparent),
   highlight_(false),
   oldSpecialRepresentationSet_(false),
   format_(format),
   numChildren_(0),
-  childrenFetched_(false),
+  tqchildrenFetched_(false),
   updateUnconditionally_(false),
   frozen_(false),
   initialCreation_(false),
@@ -1146,7 +1146,7 @@ VarItem::VarItem(TrimmableItem *parent, const GDBMI::Value& varobj,
 
     controller_ = varTree()->controller();
 
-    // Set type and children.
+    // Set type and tqchildren.
     originalValueType_ = varobj["type"].literal();
     numChildren_ = varobj["numchild"].literal().toInt();
     setExpandable(numChildren_ != 0);
@@ -1159,7 +1159,7 @@ VarItem::VarItem(TrimmableItem *parent, const GDBMI::Value& varobj,
 void VarItem::createVarobj()
 {
     TQString old = varobjName_;
-    varobjName_ = TQString("KDEV%1").arg(varobjIndex++);
+    varobjName_ = TQString("KDEV%1").tqarg(varobjIndex++);
     emit varobjNameChange(old, varobjName_);
 
     if (frozen_)
@@ -1169,7 +1169,7 @@ void VarItem::createVarobj()
         // variable and we create variable object from that.
         controller_->addCommand(
             new CliCommand(
-                TQString("print %1").arg(expression_),
+                TQString("print %1").tqarg(expression_),
                 this,
                 &VarItem::handleCliPrint));
     }
@@ -1177,7 +1177,7 @@ void VarItem::createVarobj()
     {
         controller_->addCommand(
             new CliCommand(
-                TQString("print /x &%1").arg(expression_),
+                TQString("print /x &%1").tqarg(expression_),
                 this,
                 &VarItem::handleCurrentAddress,
                 true));
@@ -1186,8 +1186,8 @@ void VarItem::createVarobj()
             // Need to quote expression, otherwise gdb won't like
             // spaces inside it.
             new GDBCommand(TQString("-var-create %1 * \"%2\"")
-                           .arg(varobjName_)
-                           .arg(expression_),
+                           .tqarg(varobjName_)
+                           .tqarg(expression_),
                            this,
                            &VarItem::varobjCreated,
                            initialCreation_ ? false : true));
@@ -1209,7 +1209,7 @@ void VarItem::varobjCreated(const GDBMI::ResultRecord& r)
     originalValueType_ = r["type"].literal();
     if (!oldType.isEmpty() && oldType != originalValueType_)
     {
-        // Type changed, the children might be no longer valid,
+        // Type changed, the tqchildren might be no longer valid,
         // so delete them.
         for(TQListViewItem* child = firstChild(); child; )
         {
@@ -1239,7 +1239,7 @@ void VarItem::setVarobjName(const TQString& name)
     {
         controller_->addCommand(
             new GDBCommand(TQString("-var-set-format \"%1\" %2")
-                           .arg(varobjName_).arg(varobjFormatName())));
+                           .tqarg(varobjName_).tqarg(varobjFormatName())));
     }
 
     // Get the initial value.
@@ -1247,7 +1247,7 @@ void VarItem::setVarobjName(const TQString& name)
 
     if (isOpen())
     {
-        // This regets children list.
+        // This regets tqchildren list.
         setOpen(true);
     }
 }
@@ -1333,18 +1333,18 @@ void VarItem::valueDone(const GDBMI::ResultRecord& r)
 }
 
 void VarItem::createChildren(const GDBMI::ResultRecord& r,
-                             bool children_of_fake)
+                             bool tqchildren_of_fake)
 {
-    const GDBMI::Value& children = r["children"];
+    const GDBMI::Value& tqchildren = r["tqchildren"];
 
     /* In order to figure out which variable objects correspond
        to base class subobject, we first must detect if *this
        is a structure type. We use present of 'public'/'private'/'protected'
        fake child as an indicator. */
     bool structureType = false;
-    if (!children_of_fake && children.size() > 0)
+    if (!tqchildren_of_fake && tqchildren.size() > 0)
     {
-        TQString exp = children[0]["exp"].literal();
+        TQString exp = tqchildren[0]["exp"].literal();
         bool ok = false;
         exp.toInt(&ok);
         if (!ok || exp[0] != '*')
@@ -1353,23 +1353,23 @@ void VarItem::createChildren(const GDBMI::ResultRecord& r,
         }
     }
 
-    for (unsigned i = 0; i < children.size(); ++i)
+    for (unsigned i = 0; i < tqchildren.size(); ++i)
     {
-        TQString exp = children[i]["exp"].literal();
+        TQString exp = tqchildren[i]["exp"].literal();
         // For artificial accessibility nodes,
-        // fetch their children.
+        // fetch their tqchildren.
         if (exp == "public" || exp == "protected" || exp == "private")
         {
-            TQString name = children[i]["name"].literal();
+            TQString name = tqchildren[i]["name"].literal();
             controller_->addCommand(new GDBCommand(
-                                        "-var-list-children \"" +
+                                        "-var-list-tqchildren \"" +
                                         name + "\"",
                                         this,
-                                        &VarItem::childrenOfFakesDone));
+                                        &VarItem::tqchildrenOfFakesDone));
         }
         else
         {
-            /* All children of structures that are not artifical
+            /* All tqchildren of structures that are not artifical
                are base subobjects. */
             bool baseObject = structureType;
 
@@ -1388,28 +1388,28 @@ void VarItem::createChildren(const GDBMI::ResultRecord& r,
             }
             if (existing)
             {
-                existing->setVarobjName(children[i]["name"].literal());
+                existing->setVarobjName(tqchildren[i]["name"].literal());
             }
             else
             {
                 kdDebug(9012) << "Creating new varobj "
                               << exp << " " << baseObject << "\n";
-                // Propagate format from parent.
+                // Propagate format from tqparent.
                 VarItem* v = 0;
-                v = new VarItem(this, children[i], format_, baseObject);
+                v = new VarItem(this, tqchildren[i], format_, baseObject);
             }
         }
     }
 }
 
 
-void VarItem::childrenDone(const GDBMI::ResultRecord& r)
+void VarItem::tqchildrenDone(const GDBMI::ResultRecord& r)
 {
     createChildren(r, false);
-    childrenFetched_ = true;
+    tqchildrenFetched_ = true;
 }
 
-void VarItem::childrenOfFakesDone(const GDBMI::ResultRecord& r)
+void VarItem::tqchildrenOfFakesDone(const GDBMI::ResultRecord& r)
 {
     createChildren(r, true);
 }
@@ -1469,10 +1469,10 @@ TQString VarItem::displayName() const
     if (expression_[0] != '*')
         return expression_;
 
-    if (const VarItem* parent =
-        dynamic_cast<const VarItem*>(TrimmableItem::parent()))
+    if (const VarItem* tqparent =
+        dynamic_cast<const VarItem*>(TrimmableItem::tqparent()))
     {
-        return "*" + parent->displayName();
+        return "*" + tqparent->displayName();
     }
     else
     {
@@ -1504,24 +1504,24 @@ TQString VarItem::gdbExpression() const
     //  - number, for array element
     //  - identifier, for member,
     //  - ***intentifier, for derefenreced pointer.
-    const VarItem* parent = dynamic_cast<const VarItem*>(TrimmableItem::parent());
+    const VarItem* tqparent = dynamic_cast<const VarItem*>(TrimmableItem::tqparent());
 
     bool ok = false;
     expression_.toInt(&ok);
     if (ok)
     {
-        // Array, parent always exists.
-        return parent->gdbExpression() + "[" + expression_ + "]";
+        // Array, tqparent always exists.
+        return tqparent->gdbExpression() + "[" + expression_ + "]";
     }
     else if (expression_[0] == '*')
     {
-        if (parent)
+        if (tqparent)
         {
             // For MI, expression_ can be "*0" (meaing
             // references 0-th element of some array).
-            // So, we really need to get to the parent to computed the right
+            // So, we really need to get to the tqparent to computed the right
             // gdb expression.
-            return "*" + parent->gdbExpression();
+            return "*" + tqparent->gdbExpression();
         }
         else
         {
@@ -1532,14 +1532,14 @@ TQString VarItem::gdbExpression() const
     }
     else
     {
-        if (parent)
+        if (tqparent)
             /* This is varitem corresponds to a base suboject,
-               the expression should cast parent to the base's
+               the expression should cast tqparent to the base's
                type. */
             if (baseClassMember_)
-                return "((" + expression_ + ")" + parent->gdbExpression() + ")";
+                return "((" + expression_ + ")" + tqparent->gdbExpression() + ")";
             else
-                return parent->gdbExpression() + "." + expression_;
+                return tqparent->gdbExpression() + "." + expression_;
         else
             return expression_;
     }
@@ -1603,8 +1603,8 @@ void VarItem::updateValue()
 void VarItem::setValue(const TQString& new_value)
 {
     controller_->addCommand(
-        new GDBCommand(TQString("-var-assign \"%1\" %2").arg(varobjName_)
-                       .arg(new_value)));
+        new GDBCommand(TQString("-var-assign \"%1\" %2").tqarg(varobjName_)
+                       .tqarg(new_value)));
 
     // And immediately reload it from gdb,
     // so that it's display format is the one gdb uses,
@@ -1619,12 +1619,12 @@ void VarItem::updateSpecialRepresentation(const TQString& xs)
     TQString s(xs);
     if (s[0] == '$')
     {
-        int i = s.find('=');
+        int i = s.tqfind('=');
         if (i != -1)
             s = s.mid(i+2);
     }
 
-    // A hack to nicely display QStrings. The content of TQString is unicode
+    // A hack to nicely display TQStrings. The content of TQString is tqunicode
     // for for ASCII only strings we get ascii character mixed with \000.
     // Remove those \000 now.
 
@@ -1638,7 +1638,7 @@ void VarItem::updateSpecialRepresentation(const TQString& xs)
     // one TQChar from two characters from gdb. But to do that, we *should*
     // now if the data if generic gdb value, and result of request for string
     // data. Fixing is is for later.
-    s.replace( TQRegExp("\\\\000|\\\\0"), "" );
+    s.tqreplace( TQRegExp("\\\\000|\\\\0"), "" );
 
     // FIXME: for now, assume that all special representations are
     // just strings.
@@ -1661,14 +1661,14 @@ void VarItem::recreateLocallyMaybe()
 {
     controller_->addCommand(
         new CliCommand(
-            TQString("print /x &%1").arg(expression_),
+            TQString("print /x &%1").tqarg(expression_),
             this,
             &VarItem::handleCurrentAddress,
             true));
 
     controller_->addCommand(
         new CliCommand(
-            TQString("whatis %1").arg(expression_),
+            TQString("whatis %1").tqarg(expression_),
             this,
             &VarItem::handleType));
 }
@@ -1688,12 +1688,12 @@ void VarItem::setOpen(bool open)
 {
     TQListViewItem::setOpen(open);
 
-    if (open && !childrenFetched_)
+    if (open && !tqchildrenFetched_)
     {
         controller_->addCommand(new GDBCommand(
-                                    "-var-list-children \"" + varobjName_ + "\"",
+                                    "-var-list-tqchildren \"" + varobjName_ + "\"",
                                     this,
-                                    &VarItem::childrenDone));
+                                    &VarItem::tqchildrenDone));
     }
 }
 
@@ -1703,7 +1703,7 @@ bool VarItem::handleSpecialTypes()
     if (originalValueType_.isEmpty())
         return false;
 
-    static TQRegExp qstring("^(const)?[ ]*QString[ ]*&?$");
+    static TQRegExp qstring("^(const)?[ ]*TQString[ ]*&?$");
 
     if (qstring.exactMatch(originalValueType_)) {
 
@@ -1712,7 +1712,7 @@ bool VarItem::handleSpecialTypes()
             return false;
         varTree->controller()->addCommand(
             new ResultlessCommand(TQString("print $kdev_d=%1.d")
-                                  .arg(gdbExpression()),
+                                  .tqarg(gdbExpression()),
                                   true /* ignore error */));
 
         if (varTree->controller()->qtVersion() >= 4)
@@ -1736,7 +1736,7 @@ bool VarItem::handleSpecialTypes()
         else
             varTree->controller()->addCommand(
                 new ValueSpecialRepresentationCommand(
-                    this, "print ($kdev_s>0) ? (*((char*)&$kdev_d.unicode[0])@$kdev_s) : \"\""));
+                    this, "print ($kdev_s>0) ? (*((char*)&$kdev_d.tqunicode[0])@$kdev_s) : \"\""));
 
         return true;
     }
@@ -1760,7 +1760,7 @@ void VarItem::setFormat(format_t f)
 
     if (numChildren_)
     {
-        // If variable has children, change format for children.
+        // If variable has tqchildren, change format for tqchildren.
         // - for structures, that's clearly right
         // - for arrays, that's clearly right
         // - for pointers, this can be confusing, but nobody ever wants to
@@ -1775,7 +1775,7 @@ void VarItem::setFormat(format_t f)
     {
          controller_->addCommand(
             new GDBCommand(TQString("-var-set-format \"%1\" %2")
-                           .arg(varobjName_).arg(varobjFormatName())));
+                           .tqarg(varobjName_).tqarg(varobjFormatName())));
 
         updateValue();
     }
@@ -1853,7 +1853,7 @@ void VarItem::paintCell(TQPainter *p, const TQColorGroup &cg,
     if (!alive_)
     {
         /* Draw this as disabled. */
-        TQListViewItem::paintCell(p, varTree()->TQWidget::palette().disabled(),
+        TQListViewItem::paintCell(p, varTree()->TQWidget::tqpalette().disabled(),
                                  column, width, align);
     }
     else
@@ -1876,8 +1876,8 @@ VariableTree* VarItem::varTree() const
 
 void VarItem::unhookFromGdb()
 {
-    // Unhook children first, so that child varitems are deleted
-    // before parent. Strictly speaking, we can avoid calling
+    // Unhook tqchildren first, so that child varitems are deleted
+    // before tqparent. Strictly speaking, we can avoid calling
     // -var-delete on child varitems, but that's a bit cheesy,
     for(TQListViewItem* child = firstChild();
         child; child = child->nextSibling())
@@ -1886,7 +1886,7 @@ void VarItem::unhookFromGdb()
     }
 
     alive_ = false;
-    childrenFetched_ = false;
+    tqchildrenFetched_ = false;
 
     emit varobjNameChange(varobjName_, "");
 
@@ -1894,7 +1894,7 @@ void VarItem::unhookFromGdb()
     {
         controller_->addCommand(
             new GDBCommand(
-                TQString("-var-delete \"%1\"").arg(varobjName_)));
+                TQString("-var-delete \"%1\"").tqarg(varobjName_)));
     }
 
     varobjName_ = "";
@@ -1931,8 +1931,8 @@ bool VarItem::isAlive() const
 // **************************************************************************
 // **************************************************************************
 
-VarFrameRoot::VarFrameRoot(VariableTree *parent, int frameNo, int threadNo)
-    : TrimmableItem (parent),
+VarFrameRoot::VarFrameRoot(VariableTree *tqparent, int frameNo, int threadNo)
+    : TrimmableItem (tqparent),
       needLocals_(false),
       frameNo_(frameNo),
       threadNo_(threadNo),
@@ -1956,8 +1956,8 @@ void VarFrameRoot::setOpen(bool open)
     if (frameOpened && needLocals_)
     {
         needLocals_ = false;
-        VariableTree* parent = static_cast<VariableTree*>(listView());
-        parent->updateCurrentFrame();
+        VariableTree* tqparent = static_cast<VariableTree*>(listView());
+        tqparent->updateCurrentFrame();
     }
 }
 
@@ -1978,8 +1978,8 @@ void VarFrameRoot::setDirty()
 // **************************************************************************
 // **************************************************************************
 
-WatchRoot::WatchRoot(VariableTree *parent)
-    : TrimmableItem(parent)
+WatchRoot::WatchRoot(VariableTree *tqparent)
+    : TrimmableItem(tqparent)
 {
     setText(0, i18n("Watch"));
     setOpen(true);