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

25 files changed, 267 insertions, 254 deletions

diff --git a/languages/ruby/debugger/breakpoint.cpp b/languages/ruby/debugger/breakpoint.cpp
index c9a91ec4..972a13a4 100644
--- a/languages/ruby/debugger/breakpoint.cpp
+++ b/languages/ruby/debugger/breakpoint.cpp
@@ -70,7 +70,7 @@ Breakpoint::~Breakpoint()
 TQString Breakpoint::dbgRemoveCommand() const
 {
 //    if (dbgId_>0)
-//        return TQString("delete %1").arg(dbgId_); // gdb command - not translatable
+//        return TQString("delete %1").tqarg(dbgId_); // gdb command - not translatable
 
     return TQString();
 }
@@ -161,9 +161,9 @@ TQString FilePosBreakpoint::dbgSetCommand() const
 {
     TQString cmdStr;
     if (fileName_.isEmpty())
-        cmdStr = TQString("break %1").arg(lineNo_);  // gdb command - not translatable
+        cmdStr = TQString("break %1").tqarg(lineNo_);  // gdb command - not translatable
     else {
-        cmdStr = TQString("break %1:%2").arg(fileName_).arg(lineNo_);
+        cmdStr = TQString("break %1:%2").tqarg(fileName_).tqarg(lineNo_);
     }
 
     if (isTemporary())
diff --git a/languages/ruby/debugger/dbgcontroller.h b/languages/ruby/debugger/dbgcontroller.h
index 56aaee11..6fe2e0db 100644
--- a/languages/ruby/debugger/dbgcontroller.h
+++ b/languages/ruby/debugger/dbgcontroller.h
@@ -77,9 +77,10 @@ enum RttiValues {
 /***************************************************************************/
 /***************************************************************************/
 /***************************************************************************/
-class DbgController : public QObject
+class DbgController : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
 
@@ -126,7 +127,7 @@ public slots:
     virtual void slotBPState(const Breakpoint&)                             = 0;
 
 
-    virtual void slotExpandItem(VarItem *parent,
+    virtual void slotExpandItem(VarItem *tqparent,
                                     const TQCString &userRequest)            = 0;
     virtual void slotSelectFrame(int frame, int thread, 
 	                                const TQString& frameName)               = 0;
@@ -150,7 +151,7 @@ signals:
     void rdbStdout            (const char *output);
     void rdbStderr            (const char *output);
     void showStepInSource     (const TQString &fileName, int lineNum, const TQString &address);
-    void dbgStatus            (const TQString &status, int statusFlag);
+    void dbgtqStatus            (const TQString &status, int statusFlag);
 
 protected:
     KProcess *dbgProcess_;
diff --git a/languages/ruby/debugger/dbgpsdlg.cpp b/languages/ruby/debugger/dbgpsdlg.cpp
index d5458c28..336a48b6 100644
--- a/languages/ruby/debugger/dbgpsdlg.cpp
+++ b/languages/ruby/debugger/dbgpsdlg.cpp
@@ -51,8 +51,8 @@ namespace RDBDebugger
 // For use with the internal debugger, but this dialog doesn't know anything
 // about why it's doing it.
 
-Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *parent, const char *name)
-    : KDialog(parent, name, true),      // modal
+Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *tqparent, const char *name)
+    : KDialog(tqparent, name, true),      // modal
       psProc_(0),
       pids_(new TQListBox(this)),
       heading_(new TQLabel(" ", this)),
@@ -64,8 +64,8 @@ Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *parent, const char *name)
 
     heading_->setFont(KGlobalSettings::fixedFont());
     heading_->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
-    heading_->setMaximumHeight(heading_->sizeHint().height());
-//    heading_->setMinimumSize(heading_->sizeHint());
+    heading_->setMaximumHeight(heading_->tqsizeHint().height());
+//    heading_->setMinimumSize(heading_->tqsizeHint());
     topLayout->addWidget(heading_, 5);
 
     topLayout->addWidget(pids_, 5);
@@ -75,7 +75,7 @@ Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *parent, const char *name)
     TQPushButton *ok       = buttonbox->addButton(KStdGuiItem::ok());
     buttonbox->addStretch();
     TQPushButton *cancel   = buttonbox->addButton(KStdGuiItem::cancel());
-    buttonbox->layout();
+    buttonbox->tqlayout();
     topLayout->addWidget(buttonbox);
 
     connect(ok,     TQT_SIGNAL(clicked()),  TQT_SLOT(accept()));
@@ -149,14 +149,14 @@ void Dbg_PS_Dialog::slotProcessExited()
 
     pidLines_ += '\n';
 
-    int start = pidLines_.find('\n', 0);  // Skip the first line (header line)
+    int start = pidLines_.tqfind('\n', 0);  // Skip the first line (header line)
     int pos;
     if (start != -1)
         heading_->setText(pidLines_.left(start));
-    while ( (pos = pidLines_.find('\n', start)) != -1) {
+    while ( (pos = pidLines_.tqfind('\n', start)) != -1) {
         TQString item = pidLines_.mid(start, pos-start);
         if (!item.isEmpty()) {
-            if (item.find(pidCmd_) == -1)
+            if (item.tqfind(pidCmd_) == -1)
                 pids_->insertItem(item);
         }
 
diff --git a/languages/ruby/debugger/dbgpsdlg.h b/languages/ruby/debugger/dbgpsdlg.h
index 928e4c54..1f30d6a7 100644
--- a/languages/ruby/debugger/dbgpsdlg.h
+++ b/languages/ruby/debugger/dbgpsdlg.h
@@ -36,9 +36,10 @@ namespace RDBDebugger
 class Dbg_PS_Dialog : public KDialog
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    Dbg_PS_Dialog( TQWidget *parent=0, const char *name=0 );
+    Dbg_PS_Dialog( TQWidget *tqparent=0, const char *name=0 );
     ~Dbg_PS_Dialog();
 
     int pidSelected();
diff --git a/languages/ruby/debugger/dbgtoolbar.cpp b/languages/ruby/debugger/dbgtoolbar.cpp
index 36b42f07..706b6284 100644
--- a/languages/ruby/debugger/dbgtoolbar.cpp
+++ b/languages/ruby/debugger/dbgtoolbar.cpp
@@ -71,10 +71,10 @@ namespace RDBDebugger
 // the iconify, close, etc buttons from the window title but again I kept running
 // into problems. Instead, I used no decoration and this class. Also this looks
 // similar to the KToolBar floating style.
-class DbgMoveHandle : public QFrame
+class DbgMoveHandle : public TQFrame
 {
 public:
-    DbgMoveHandle(DbgToolBar *parent=0, const char * name=0, WFlags f=0);
+    DbgMoveHandle(DbgToolBar *tqparent=0, const char * name=0, WFlags f=0);
     virtual ~DbgMoveHandle();
 
     virtual void mousePressEvent(TQMouseEvent *e);
@@ -89,9 +89,9 @@ private:
 
 // **************************************************************************
 
-DbgMoveHandle::DbgMoveHandle(DbgToolBar *parent, const char * name, WFlags f)
-    : TQFrame(parent, name, f),
-      toolBar_(parent),
+DbgMoveHandle::DbgMoveHandle(DbgToolBar *tqparent, const char * name, WFlags f)
+    : TQFrame(tqparent, name, f),
+      toolBar_(tqparent),
       offset_(TQPoint(0,0)),
       moving_(false)
 {
@@ -113,21 +113,21 @@ void DbgMoveHandle::mousePressEvent(TQMouseEvent *e)
     if (moving_)
         return;
 
-    if (e->button() == RightButton) {
+    if (e->button() == Qt::RightButton) {
         KPopupMenu *menu = new KPopupMenu(this);
 	menu->insertTitle(i18n("Debug Toolbar"));
         menu->insertItem(i18n("Dock to Panel"),
-                         parent(), TQT_SLOT(slotDock()));
+                         tqparent(), TQT_SLOT(slotDock()));
         menu->insertItem(i18n("Dock to Panel && Iconify KDevelop"),
-                         parent(), TQT_SLOT(slotIconifyAndDock()));
+                         tqparent(), TQT_SLOT(slotIconifyAndDock()));
         menu->popup(e->globalPos());
     } else {
         moving_ = true;
-        offset_ = parentWidget()->pos() - e->globalPos();
+        offset_ = tqparentWidget()->pos() - e->globalPos();
         setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
         TQApplication::setOverrideCursor(TQCursor(sizeAllCursor));
-        setPalette(TQPalette(colorGroup().background()));
-        repaint();
+        setPalette(TQPalette(tqcolorGroup().background()));
+        tqrepaint();
     }
 }
 
@@ -140,8 +140,8 @@ void DbgMoveHandle::mouseReleaseEvent(TQMouseEvent *e)
     offset_ = TQPoint(0,0);
     setFrameStyle(TQFrame::Panel|TQFrame::Raised);
     TQApplication::restoreOverrideCursor();
-    setPalette(TQPalette(colorGroup().background()));
-    repaint();
+    setPalette(TQPalette(tqcolorGroup().background()));
+    tqrepaint();
 }
 
 // **************************************************************************
@@ -159,16 +159,16 @@ void DbgMoveHandle::mouseMoveEvent(TQMouseEvent *e)
 // **************************************************************************
 // **************************************************************************
 
-// This class adds text _and_ a pixmap to a button. Why doesn't QPushButton
+// This class adds text _and_ a pixmap to a button. Why doesn't TQPushButton
 // support that? It only allowed text _or_ pixmap.
-class DbgButton : public QPushButton
+class DbgButton : public TQPushButton
 {
 public:
     DbgButton(const TQPixmap &pixmap, const TQString &text,
-              DbgToolBar *parent, const char *name=0);
+              DbgToolBar *tqparent, const char *name=0);
     virtual ~DbgButton() {};
     void drawButtonLabel(TQPainter *painter);
-    TQSize sizeHint() const;
+    TQSize tqsizeHint() const;
 
 private:
     TQPixmap pixmap_;
@@ -177,8 +177,8 @@ private:
 // **************************************************************************
 
 DbgButton::DbgButton(const TQPixmap& pixmap, const TQString& text,
-                     DbgToolBar* parent, const char* name)
-    : TQPushButton(parent, name),
+                     DbgToolBar* tqparent, const char* name)
+    : TQPushButton(tqparent, name),
       pixmap_(pixmap)
 {
     setText(text);
@@ -197,27 +197,27 @@ void DbgButton::drawButtonLabel(TQPainter *painter)
     painter->drawPixmap(x, y, pixmap_);
 
     if (hasText) {
-        painter->setPen(colorGroup().text());
+        painter->setPen(tqcolorGroup().text());
         painter->drawText(height()+2, 0, width()-(height()+2), height(), AlignLeft|AlignVCenter, text());
     }
 }
 
 // **************************************************************************
 
-TQSize DbgButton::sizeHint() const
+TQSize DbgButton::tqsizeHint() const
 {
     if (text().isEmpty())
         return pixmap_.size();
     else
-        return TQPushButton::sizeHint();
+        return TQPushButton::tqsizeHint();
 }
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
-DbgDocker::DbgDocker(TQWidget* parent, DbgToolBar* toolBar, const TQPixmap& pixmap) :
-    KSystemTray(parent, "DbgDocker"),
+DbgDocker::DbgDocker(TQWidget* tqparent, DbgToolBar* toolBar, const TQPixmap& pixmap) :
+    KSystemTray(tqparent, "DbgDocker"),
     toolBar_(toolBar)
 {
     setPixmap(pixmap);
@@ -228,17 +228,17 @@ DbgDocker::DbgDocker(TQWidget* parent, DbgToolBar* toolBar, const TQPixmap& pixm
 
 void DbgDocker::mousePressEvent(TQMouseEvent *e)
 {
-    if (!rect().contains( e->pos()))
+    if (!TQT_TQRECT_OBJECT(rect()).tqcontains( e->pos()))
         return;
 
     switch (e->button()) {
-    case LeftButton:
+    case Qt::LeftButton:
         {
             // Not really a click, but it'll hold for the time being !!!
             emit clicked();
             break;
         }
-    case RightButton:
+    case Qt::RightButton:
         {
             KPopupMenu* menu = new KPopupMenu(this);
 	    menu->insertTitle(i18n("Debug Toolbar"));
@@ -257,7 +257,7 @@ void DbgDocker::mousePressEvent(TQMouseEvent *e)
 // **************************************************************************
 
 DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
-                       TQWidget* parent, const char* name)
+                       TQWidget* tqparent, const char* name)
     : TQFrame(0, name),
       part_(part),
       activeWindow_(0),
@@ -267,10 +267,10 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
       appIsActive_(false),
       docked_(false),
       docker_(0),
-      dockWindow_(new KSystemTray(parent))
+      dockWindow_(new KSystemTray(tqparent))
 {
-    winModule_  = new KWinModule(this);
-    docker_ = new DbgDocker(parent, this, BarIcon("dbgnext"));
+    winModule_  = new KWinModule(TQT_TQOBJECT(this));
+    docker_ = new DbgDocker(tqparent, this, BarIcon("dbgnext"));
     connect(docker_, TQT_SIGNAL(clicked()), part_, TQT_SLOT(slotStepOver()));
 
     // Must have noFocus set so that we can see what window was active.
@@ -284,7 +284,7 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
 //    KWin::setType(winId(), NET::Override);    // So it has no decoration
     KWin::setType(winId(), NET::Dock);
 
-    setFocusPolicy(NoFocus);
+    setFocusPolicy(TQ_NoFocus);
     setFrameStyle( TQFrame::Box | TQFrame::Plain );
     setLineWidth(4);
     setMidLineWidth(0);
@@ -303,8 +303,8 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
     TQPushButton*  bStep       = new DbgButton(BarIcon("dbgstep"),       i18n("Step Into"),    this);
     TQPushButton*  bFinish     = new DbgButton(BarIcon("dbgstepout"),    i18n("Step Out"),   this);
     TQPushButton*  bRunTo      = new DbgButton(BarIcon("dbgrunto"),      i18n("Run to Cursor"),   this);
-    bPrevFocus_ = new DbgButton(BarIcon("dbgmemview"),    TQString::null,      this);
-    bKDevFocus_ = new DbgButton(BarIcon("kdevelop"),      TQString::null,      this);
+    bPrevFocus_ = new DbgButton(BarIcon("dbgmemview"),    TQString(),      this);
+    bKDevFocus_ = new DbgButton(BarIcon("kdevelop"),      TQString(),      this);
 
   connect(bRun,        TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotRun()));
   connect(bInterrupt,  TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotPause()));
@@ -351,12 +351,12 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
 
     nextLayout->addWidget(bNext);
 
-//     int w = QMAX(bRun->sizeHint().width(), bFinish->sizeHint().width());
-//     w = QMAX(w, bInterrupt->sizeHint().width());
-//     w = QMAX(w, bView->sizeHint().width());
+//     int w = TQMAX(bRun->tqsizeHint().width(), bFinish->tqsizeHint().width());
+//     w = TQMAX(w, bInterrupt->tqsizeHint().width());
+//     w = TQMAX(w, bView->tqsizeHint().width());
 
     // they should have the same height, so don't be too fussy
-//     int h = bFinish->sizeHint().height();
+//     int h = bFinish->tqsizeHint().height();
 //
 //     bNext->setMinimumHeight(h);
 //     bNexti->setMinimumHeight(h);
@@ -390,10 +390,10 @@ void DbgToolBar::slotKdevFocus()
     // If anyone has a way of determining what window the app is _actually_ running on
     // then please fix and send a patch.
 
-    if (winModule_->activeWindow() != topLevelWidget()->winId())
+    if (winModule_->activeWindow() != tqtopLevelWidget()->winId())
         activeWindow_ = winModule_->activeWindow();
 
-    KWin::activateWindow(topLevelWidget()->winId());
+    KWin::activateWindow(tqtopLevelWidget()->winId());
 }
 
 // **************************************************************************
@@ -407,7 +407,7 @@ void DbgToolBar::slotPrevFocus()
 
 // If the app is active then the app button is highlighted, otherwise
 // kdev button is highlighted.
-void DbgToolBar::slotDbgStatus(const TQString&, int state)
+void DbgToolBar::slotDbgtqStatus(const TQString&, int state)
 {
     bool appIndicator = state & s_appBusy;
     if (appIndicator != appIsActive_) {
@@ -421,11 +421,11 @@ void DbgToolBar::slotDbgStatus(const TQString&, int state)
 void DbgToolBar::setAppIndicator(bool appIndicator)
 {
     if (appIndicator) {
-        bPrevFocus_->setPalette(TQPalette(colorGroup().mid()));
-        bKDevFocus_->setPalette(TQPalette(colorGroup().background()));
+        bPrevFocus_->setPalette(TQPalette(tqcolorGroup().mid()));
+        bKDevFocus_->setPalette(TQPalette(tqcolorGroup().background()));
     } else {
-        bPrevFocus_->setPalette(TQPalette(colorGroup().background()));
-        bKDevFocus_->setPalette(TQPalette(colorGroup().mid()));
+        bPrevFocus_->setPalette(TQPalette(tqcolorGroup().background()));
+        bKDevFocus_->setPalette(TQPalette(tqcolorGroup().mid()));
     }
 }
 
@@ -473,7 +473,7 @@ void DbgToolBar::slotActivateAndUndock()
     if (!docked_)
         return;
 
-    KWin::activateWindow(topLevelWidget()->winId());
+    KWin::activateWindow(tqtopLevelWidget()->winId());
     slotUndock();
 }
 
diff --git a/languages/ruby/debugger/dbgtoolbar.h b/languages/ruby/debugger/dbgtoolbar.h
index a83c120a..2d059cec 100644
--- a/languages/ruby/debugger/dbgtoolbar.h
+++ b/languages/ruby/debugger/dbgtoolbar.h
@@ -39,9 +39,10 @@ class RubyDebuggerPart;
 class DbgDocker : public KSystemTray
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    DbgDocker(TQWidget *parent, DbgToolBar *toolBar, const TQPixmap &pixmap);
+    DbgDocker(TQWidget *tqparent, DbgToolBar *toolBar, const TQPixmap &pixmap);
     virtual ~DbgDocker()  {};
     virtual void mousePressEvent(TQMouseEvent *e);
 
@@ -53,16 +54,17 @@ private:
 };
 
 
-class DbgToolBar : public QFrame
+class DbgToolBar : public TQFrame
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    DbgToolBar(RubyDebuggerPart *part, TQWidget* parent, const char* name=0);
+    DbgToolBar(RubyDebuggerPart *part, TQWidget* tqparent, const char* name=0);
     virtual ~DbgToolBar();
 
 private slots:
-    void slotDbgStatus(const TQString&, int);
+    void slotDbgtqStatus(const TQString&, int);
     void slotDock();
     void slotUndock();
     void slotIconifyAndDock();
diff --git a/languages/ruby/debugger/debuggee.rb b/languages/ruby/debugger/debuggee.rb
index 38e2dea7..51df5867 100644
--- a/languages/ruby/debugger/debuggee.rb
+++ b/languages/ruby/debugger/debuggee.rb
@@ -441,7 +441,7 @@ class Context
 	  stdout.printf "Set watchpoint %d\n", break_points.size, exp
 
 	when /^\s*b(?:reak)?$/
-	  if break_points.find{|b| b[1] == 0}
+	  if break_points.tqfind{|b| b[1] == 0}
 	    n = 1
 	    stdout.print "Breakpoints:\n"
 	    for b in break_points
@@ -451,7 +451,7 @@ class Context
 	      n += 1
 	    end
 	  end
-	  if break_points.find{|b| b[1] == 1}
+	  if break_points.tqfind{|b| b[1] == 1}
 	    n = 1
 	    stdout.print "\n"
 	    stdout.print "Watchpoints:\n"
@@ -827,7 +827,7 @@ EOHELP
       exit
     end
 
-    if @catch and ($!.class.ancestors.find { |e| e.to_s == @catch })
+    if @catch and ($!.class.ancestors.tqfind { |e| e.to_s == @catch })
       stdout.printf "%s:%d: `%s' (%s)\n", file, line, $!, $!.class
       fs = @frames.size
       tb = caller(0)[-fs..-1]
diff --git a/languages/ruby/debugger/debuggerpart.cpp b/languages/ruby/debugger/debuggerpart.cpp
index 3e46a3d4..7a953fe4 100644
--- a/languages/ruby/debugger/debuggerpart.cpp
+++ b/languages/ruby/debugger/debuggerpart.cpp
@@ -72,8 +72,8 @@ static const KDevPluginInfo data("kdevrbdebugger");
 typedef KDevGenericFactory<RubyDebuggerPart> RubyDebuggerFactory;
 K_EXPORT_COMPONENT_FACTORY( libkdevrbdebugger, RubyDebuggerFactory( data ) )
 
-RubyDebuggerPart::RubyDebuggerPart( TQObject *parent, const char *name, const TQStringList & ) :
-    KDevPlugin( &data, parent, name ? name : "RubyDebuggerPart" ),
+RubyDebuggerPart::RubyDebuggerPart( TQObject *tqparent, const char *name, const TQStringList & ) :
+    KDevPlugin( &data, tqparent, name ? name : "RubyDebuggerPart" ),
     controller(0)
 {
 //    setObjId("RubyDebuggerInterface");
@@ -312,16 +312,16 @@ void RubyDebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
     if (econtext->url().isLocalFile())
     {
         int id = popup->insertItem( i18n("Toggle Breakpoint"), this, TQT_SLOT(toggleBreakpoint()) );
-        popup->setWhatsThis(id, i18n("<b>Toggle breakpoint</b><p>Toggles breakpoint at the current line."));
+        popup->tqsetWhatsThis(id, i18n("<b>Toggle breakpoint</b><p>Toggles breakpoint at the current line."));
     }
     if (!m_contextIdent.isEmpty())
     {
         TQString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
-        int id = popup->insertItem( i18n("Watch: %1").arg(squeezed), this, TQT_SLOT(contextWatch()) );
-        popup->setWhatsThis(id, i18n("<b>Watch</b><p>Adds an expression under the cursor to the Variables/Watch list."));
+        int id = popup->insertItem( i18n("Watch: %1").tqarg(squeezed), this, TQT_SLOT(contextWatch()) );
+        popup->tqsetWhatsThis(id, i18n("<b>Watch</b><p>Adds an expression under the cursor to the Variables/Watch list."));
         
-		id = popup->insertItem( i18n("Inspect: %1").arg(squeezed), this, TQT_SLOT(contextRubyInspect()) );
-        popup->setWhatsThis(id, i18n("<b>Inspect</b><p>Evaluates an expression under the cursor."));
+		id = popup->insertItem( i18n("Inspect: %1").tqarg(squeezed), this, TQT_SLOT(contextRubyInspect()) );
+        popup->tqsetWhatsThis(id, i18n("<b>Inspect</b><p>Evaluates an expression under the cursor."));
     }
 }
 
@@ -412,8 +412,8 @@ void RubyDebuggerPart::setupController()
 
 
     // controller -> this
-    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
-             this,                  TQT_SLOT(slotStatus(const TQString&, int)));
+    connect( controller,            TQT_SIGNAL(dbgtqStatus(const TQString&, int)),
+             this,                  TQT_SLOT(slottqStatus(const TQString&, int)));
     connect( controller,            TQT_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
              this,                  TQT_SLOT(slotShowStep(const TQString&, int)));
 
@@ -428,8 +428,8 @@ void RubyDebuggerPart::setupController()
              rdbOutputWidget,       TQT_SLOT(slotReceivedStdout(const char*)) );
     connect( controller,            TQT_SIGNAL(rdbStderr(const char*)),
              rdbOutputWidget,       TQT_SLOT(slotReceivedStderr(const char*)) );
-    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
-             rdbOutputWidget,       TQT_SLOT(slotDbgStatus(const TQString&, int)));
+    connect( controller,            TQT_SIGNAL(dbgtqStatus(const TQString&, int)),
+             rdbOutputWidget,       TQT_SLOT(slotDbgtqStatus(const TQString&, int)));
 
 }
 
@@ -478,7 +478,7 @@ bool RubyDebuggerPart::startDebugger()
         {
             KMessageBox::error(
                 mainWindow()->main(),
-                i18n("Could not locate the debugging shell '%1'.").arg( shell ),
+                i18n("Could not locate the debugging shell '%1'.").tqarg( shell ),
                 i18n("Debugging Shell Not Found") );
             return false;
         }
@@ -683,7 +683,7 @@ void RubyDebuggerPart::slotRefreshBPState( const Breakpoint& BP)
 }
 
 
-void RubyDebuggerPart::slotStatus(const TQString &msg, int state)
+void RubyDebuggerPart::slottqStatus(const TQString &msg, int state)
 {
     TQString stateIndicator;
 
diff --git a/languages/ruby/debugger/debuggerpart.h b/languages/ruby/debugger/debuggerpart.h
index c78a53ee..5f3a06a6 100644
--- a/languages/ruby/debugger/debuggerpart.h
+++ b/languages/ruby/debugger/debuggerpart.h
@@ -48,9 +48,10 @@ class RDBOutputWidget;
 class RubyDebuggerPart : public KDevPlugin
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    RubyDebuggerPart( TQObject *parent, const char *name, const TQStringList & );
+    RubyDebuggerPart( TQObject *tqparent, const char *name, const TQStringList & );
     ~RubyDebuggerPart();
     virtual void restorePartialProjectSession(const TQDomElement* el);
     virtual void savePartialProjectSession(TQDomElement* el);
@@ -75,7 +76,7 @@ private slots:
     void slotStepOut();
 
     void slotRefreshBPState(const Breakpoint&);
-    void slotStatus(const TQString &msg, int state);
+    void slottqStatus(const TQString &msg, int state);
     void slotShowStep(const TQString &fileName, int lineNum);
     void slotGotoSource(const TQString &fileName, int lineNum);
 
diff --git a/languages/ruby/debugger/framestackwidget.cpp b/languages/ruby/debugger/framestackwidget.cpp
index c8083dc8..d98582c5 100644
--- a/languages/ruby/debugger/framestackwidget.cpp
+++ b/languages/ruby/debugger/framestackwidget.cpp
@@ -41,8 +41,8 @@
 namespace RDBDebugger
 {
 
-FramestackWidget::FramestackWidget(TQWidget *parent, const char *name, WFlags f)
-        : TQListView(parent, name, f),
+FramestackWidget::FramestackWidget(TQWidget *tqparent, const char *name, WFlags f)
+        : TQListView(tqparent, name, f),
         viewedThread_(0)
 {
     setRootIsDecorated(true);
@@ -119,7 +119,7 @@ void FramestackWidget::parseRDBThreadList(char *str)
 		ThreadStackItem* thread;
         thread = new ThreadStackItem(	this,
 										thread_re.cap(2).toInt(),
-										TQString("%1 %2").arg(thread_re.cap(2)).arg(thread_re.cap(3)) );
+										TQString("%1 %2").tqarg(thread_re.cap(2)).tqarg(thread_re.cap(3)) );
 		// The thread with a '+' is always the viewedthread
         if (thread_re.cap(1) == "+") {
             viewedThread_ = thread;
@@ -136,11 +136,11 @@ void FramestackWidget::parseRDBThreadList(char *str)
 
 void FramestackWidget::parseRDBBacktraceList(char *str)
 {
-	QRegExp	frame_re("#(\\d+) ([^:]+):(\\d+)(:in `([^\\n]+)')?");
+	TQRegExp	frame_re("#(\\d+) ([^:]+):(\\d+)(:in `([^\\n]+)')?");
 	int	pos = frame_re.search(str);
 	
     while (pos != -1) {
-		QString	method(frame_re.cap(5));
+		TQString	method(frame_re.cap(5));
 		if (method == "") {
 			method = "toplevel";
 		} else {
@@ -148,7 +148,7 @@ void FramestackWidget::parseRDBBacktraceList(char *str)
 		}
 		
 		int frameNo = frame_re.cap(1).toInt();
-		TQString frameName = TQString("T%1#%2 %3").arg(viewedThread_->threadNo()).arg(frame_re.cap(1)).arg(method);
+		TQString frameName = TQString("T%1#%2 %3").tqarg(viewedThread_->threadNo()).tqarg(frame_re.cap(1)).tqarg(method);
 		new FrameStackItem(viewedThread_, frameNo, TQString(frame_re.cap(0)), frameName);
 		
 		// Tell the Variable Tree that this frame is active
@@ -211,10 +211,10 @@ FrameStackItem *FramestackWidget::findFrame(int frameNo, int threadNo)
 
 // **************************************************************************
 
-FrameStackItem::FrameStackItem(ThreadStackItem *parent, int frameNo, const TQString &frameDesc, const TQString& frameName)
-        : TQListViewItem(parent),
+FrameStackItem::FrameStackItem(ThreadStackItem *tqparent, int frameNo, const TQString &frameDesc, const TQString& frameName)
+        : TQListViewItem(tqparent),
         frameNo_(frameNo),
-        threadNo_(parent->threadNo()),
+        threadNo_(tqparent->threadNo()),
 		frameName_(frameName)		
 {
 	setText(0, frameDesc);
@@ -239,8 +239,8 @@ TQString FrameStackItem::key(int /*column*/, bool /*ascending*/) const
 // **************************************************************************
 // **************************************************************************
 
-ThreadStackItem::ThreadStackItem(FramestackWidget *parent, int threadNo, const TQString &threadDesc)
-        : TQListViewItem(parent),
+ThreadStackItem::ThreadStackItem(FramestackWidget *tqparent, int threadNo, const TQString &threadDesc)
+        : TQListViewItem(tqparent),
         threadNo_(threadNo)
 {
     setText(0, threadDesc);
diff --git a/languages/ruby/debugger/framestackwidget.h b/languages/ruby/debugger/framestackwidget.h
index b000f042..59280f3b 100644
--- a/languages/ruby/debugger/framestackwidget.h
+++ b/languages/ruby/debugger/framestackwidget.h
@@ -33,10 +33,10 @@ namespace RDBDebugger
 class FramestackWidget;
 
 
-class ThreadStackItem : public QListViewItem
+class ThreadStackItem : public TQListViewItem
 {
 public:
-    ThreadStackItem(FramestackWidget *parent, int threadNo, const TQString &threadDesc);
+    ThreadStackItem(FramestackWidget *tqparent, int threadNo, const TQString &threadDesc);
     virtual ~ThreadStackItem();
 
 	virtual int rtti() const { return RTTI_THREAD_STACK_ITEM; }
@@ -52,10 +52,10 @@ private:
 /***************************************************************************/
 /***************************************************************************/
 
-class FrameStackItem : public QListViewItem
+class FrameStackItem : public TQListViewItem
 {
 public:
-    FrameStackItem(ThreadStackItem * parent, int frameNo, const TQString & frameDesc, const TQString & frameName);
+    FrameStackItem(ThreadStackItem * tqparent, int frameNo, const TQString & frameDesc, const TQString & frameName);
     virtual ~FrameStackItem();
 
 	virtual int rtti() const { return RTTI_FRAME_STACK_ITEM; }
@@ -79,12 +79,13 @@ private:
 /**
  * @author John Birch
  */
-class FramestackWidget : public QListView
+class FramestackWidget : public TQListView
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    FramestackWidget( TQWidget *parent=0, const char *name=0, WFlags f=0 );
+    FramestackWidget( TQWidget *tqparent=0, const char *name=0, WFlags f=0 );
     virtual ~FramestackWidget();
 
     void clear();
diff --git a/languages/ruby/debugger/rdbbreakpointwidget.cpp b/languages/ruby/debugger/rdbbreakpointwidget.cpp
index b9ead060..7c987289 100644
--- a/languages/ruby/debugger/rdbbreakpointwidget.cpp
+++ b/languages/ruby/debugger/rdbbreakpointwidget.cpp
@@ -56,7 +56,7 @@ enum Column {
     Control     = 0,
     Enable      = 1,
     Type        = 2,
-    Status      = 3,
+    tqStatus      = 3,
     Location    = 4
 };
 
@@ -69,7 +69,7 @@ static int m_activeFlag = 0;
 /***************************************************************************/
 /***************************************************************************/
 
-class BreakpointTableRow : public QTableItem
+class BreakpointTableRow : public TQTableItem
 {
 public:
 
@@ -93,9 +93,9 @@ private:
 /***************************************************************************/
 /***************************************************************************/
 
-BreakpointTableRow::BreakpointTableRow(TQTable* parent, EditType editType,
+BreakpointTableRow::BreakpointTableRow(TQTable* tqparent, EditType editType,
                                        Breakpoint* bp) :
-        TQTableItem(parent, editType, ""),
+        TQTableItem(tqparent, editType, ""),
         m_breakpoint(bp)
 {
     appendEmptyRow();
@@ -149,7 +149,7 @@ void BreakpointTableRow::setRow()
 
         TQString status=m_breakpoint->statusDisplay(m_activeFlag);
 
-        table()->setText(row(), Status, status);
+        table()->setText(row(), tqStatus, status);
 
         TQString displayType = m_breakpoint->displayType();
         table()->setText(row(), Location, m_breakpoint->location());
@@ -159,7 +159,7 @@ void BreakpointTableRow::setRow()
 
         table()->setText(row(), Type, displayType);
         table()->adjustColumn(Type);
-        table()->adjustColumn(Status);
+        table()->adjustColumn(tqStatus);
         table()->adjustColumn(Location);
     }
 }
@@ -168,8 +168,8 @@ void BreakpointTableRow::setRow()
 /***************************************************************************/
 /***************************************************************************/
 
-RDBBreakpointWidget::RDBBreakpointWidget(TQWidget *parent, const char *name) :
-    TQHBox(parent, name)
+RDBBreakpointWidget::RDBBreakpointWidget(TQWidget *tqparent, const char *name) :
+    TQHBox(tqparent, name)
 {
     TQFrame* toolbar = new TQFrame( this );
     TQVBoxLayout *l = new TQVBoxLayout(toolbar, 0, 0);
@@ -221,14 +221,14 @@ RDBBreakpointWidget::RDBBreakpointWidget(TQWidget *parent, const char *name) :
 
     m_table->hideColumn(Control);
     m_table->setColumnReadOnly(Type, true);
-    m_table->setColumnReadOnly(Status, true);
+    m_table->setColumnReadOnly(tqStatus, true);
     m_table->setColumnWidth( Enable, 20);
 
     TQHeader *header = m_table->horizontalHeader();
 
     header->setLabel( Enable,       "" );
     header->setLabel( Type,         i18n("Type") );
-    header->setLabel( Status,       i18n("Status") );
+    header->setLabel( tqStatus,       i18n("tqStatus") );
     header->setLabel( Location,     i18n("Location") );
 
     m_table->show();
@@ -311,7 +311,7 @@ void RDBBreakpointWidget::slotRefreshBP(const KURL &filename)
 
 /***************************************************************************/
 
-BreakpointTableRow* RDBBreakpointWidget::find(Breakpoint *breakpoint)
+BreakpointTableRow* RDBBreakpointWidget::tqfind(Breakpoint *breakpoint)
 {
     // NOTE:- The match doesn't have to be equal. Each type of bp
     // must decide on the match criteria.
@@ -398,7 +398,7 @@ void RDBBreakpointWidget::slotToggleBreakpoint(const TQString &fileName, int lin
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
-    BreakpointTableRow* btr = find(fpBP);
+    BreakpointTableRow* btr = tqfind(fpBP);
     if (btr)
     {
         delete fpBP;
@@ -414,7 +414,7 @@ void RDBBreakpointWidget::slotToggleBreakpointEnabled(const TQString &fileName,
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
-    BreakpointTableRow* btr = find(fpBP);
+    BreakpointTableRow* btr = tqfind(fpBP);
     delete fpBP;
     if (btr)
     {
@@ -429,7 +429,7 @@ void RDBBreakpointWidget::slotToggleBreakpointEnabled(const TQString &fileName,
 void RDBBreakpointWidget::slotToggleWatchpoint(const TQString &varName)
 {
     Watchpoint *watchpoint = new Watchpoint(varName, false, true);
-    BreakpointTableRow* btr = find(watchpoint);
+    BreakpointTableRow* btr = tqfind(watchpoint);
     if (btr)
     {
         removeBreakpoint(btr);
@@ -460,7 +460,7 @@ void RDBBreakpointWidget::slotSetPendingBPs()
 /***************************************************************************/
 
 // The debugger is having trouble with this bp - probably because a library
-// was unloaded and invalidated a bp that was previously set in the library
+// was unloaded and tqinvalidated a bp that was previously set in the library
 // code. Reset the bp so that we can try again later.
 void RDBBreakpointWidget::slotUnableToSetBPNow(int BPid)
 {
@@ -773,7 +773,7 @@ void RDBBreakpointWidget::slotNewValue(int row, int col)
         }
 
         case Type:
-        case Status:
+        case tqStatus:
         default:
             break;
         }
@@ -792,7 +792,7 @@ void RDBBreakpointWidget::slotEditBreakpoint(const TQString &fileName, int lineN
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
-    BreakpointTableRow* btr = find(fpBP);
+    BreakpointTableRow* btr = tqfind(fpBP);
     delete fpBP;
 
     if (btr)
@@ -889,7 +889,7 @@ void RDBBreakpointWidget::restorePartialProjectSession(const TQDomElement* el)
                 bp->setEnabled(breakpointEl.attribute( "enabled", "1").toInt());
 
                 // Add the bp if we don't already have it.
-                if (!find(bp))
+                if (!tqfind(bp))
                     addBreakpoint(bp);
                 else
                     delete bp;
@@ -904,7 +904,7 @@ void RDBBreakpointWidget::slotAddBreakpoint( )
 {
     if (m_add->popup())
     {
-        m_add->popup()->popup(mapToGlobal(this->geometry().topLeft()));
+        m_add->popup()->popup(mapToGlobal(this->tqgeometry().topLeft()));
     }
 }
 
diff --git a/languages/ruby/debugger/rdbbreakpointwidget.h b/languages/ruby/debugger/rdbbreakpointwidget.h
index 75c0dfbb..58275842 100644
--- a/languages/ruby/debugger/rdbbreakpointwidget.h
+++ b/languages/ruby/debugger/rdbbreakpointwidget.h
@@ -39,12 +39,13 @@ class Breakpoint;
 class BreakpointTableRow;
 class RDBTable;
 
-class RDBBreakpointWidget : public QHBox
+class RDBBreakpointWidget : public TQHBox
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    RDBBreakpointWidget( TQWidget* parent=0, const char* name=0 );
+    RDBBreakpointWidget( TQWidget* tqparent=0, const char* name=0 );
     virtual ~RDBBreakpointWidget();
 
     void reset();
@@ -93,7 +94,7 @@ signals:
     void clearAllBreakpoints();
 
 private:
-    BreakpointTableRow* find(Breakpoint *bp);
+    BreakpointTableRow* tqfind(Breakpoint *bp);
     BreakpointTableRow* findId(int id);
     BreakpointTableRow* findKey(int BPKey);
 
diff --git a/languages/ruby/debugger/rdbcontroller.cpp b/languages/ruby/debugger/rdbcontroller.cpp
index f0b6ea40..5dd15586 100644
--- a/languages/ruby/debugger/rdbcontroller.cpp
+++ b/languages/ruby/debugger/rdbcontroller.cpp
@@ -115,7 +115,7 @@ RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack
 {
     struct sockaddr_un	sockaddr;
 	unixSocketPath_.sprintf("/tmp/.rubydebugger%d", getpid());
-	QFileInfo			unixSocket(unixSocketPath_);
+	TQFileInfo			unixSocket(unixSocketPath_);
 	
     stdoutSizeofBuf_ = sizeof(stdoutOutput_);
     rdbSizeofBuf_ = sizeof(rdbOutput_);
@@ -236,7 +236,7 @@ void RDBController::executeCmd()
     emit rdbStdout( prettyCmd.latin1() );
 	
     if (!stateIsOn(s_silent))
-        emit dbgStatus("", state_);
+        emit dbgtqStatus("", state_);
 }
 
 // **************************************************************************
@@ -301,7 +301,7 @@ void RDBController::actOnProgramPause(const TQString &msg)
         if (stateIsOn(s_silent))
             return;
 
-        emit dbgStatus (msg, state_);
+        emit dbgtqStatus (msg, state_);
 
         // We're always at frame one when the program stops
         // and we must reset the active flag
@@ -341,14 +341,14 @@ void RDBController::programNoApp(const TQString &msg, bool msgBox)
     varTree_->viewport()->setUpdatesEnabled(false);
     varTree_->prune();
     varTree_->viewport()->setUpdatesEnabled(true);
-    varTree_->repaint();
+    varTree_->tqrepaint();
 
     frameStack_->clear();
 
     if (msgBox)
         KMessageBox::error(0, i18n("rdb message:\n")+msg);
 
-    emit dbgStatus (msg, state_);
+    emit dbgtqStatus (msg, state_);
 }
 
 // **************************************************************************
@@ -394,9 +394,9 @@ void RDBController::parseProgramLocation(char *buf)
 	}
 	
     if (stateIsOn(s_appBusy))
-        actOnProgramPause(i18n("No source: %1").arg(sourceFile));
+        actOnProgramPause(i18n("No source: %1").tqarg(sourceFile));
     else
-        emit dbgStatus (i18n("No source: %1").arg(sourceFile), state_);
+        emit dbgtqStatus (i18n("No source: %1").tqarg(sourceFile), state_);
 }
 
 // **************************************************************************
@@ -458,7 +458,7 @@ void RDBController::parseFrameMove(char *buf)
 		}
 	}
 	
-	emit dbgStatus(i18n("No source: %1").arg(sourceFile), state_);
+	emit dbgtqStatus(i18n("No source: %1").tqarg(sourceFile), state_);
 }
 
 // **************************************************************************
@@ -492,7 +492,7 @@ void RDBController::parseRequestedData(char *buf)
         varTree_->viewport()->setUpdatesEnabled(false);
         item->expandValue(buf);
         varTree_->viewport()->setUpdatesEnabled(true);
-        varTree_->repaint();
+        varTree_->tqrepaint();
     }
 }
 
@@ -505,7 +505,7 @@ void RDBController::parseFrameSelected(char *buf)
 {
     if (!stateIsOn(s_silent)) {
         emit showStepInSource("", -1, "");
-        emit dbgStatus (i18n("No source: %1").arg(TQString(buf)), state_);
+        emit dbgtqStatus (i18n("No source: %1").tqarg(TQString(buf)), state_);
     }
 }
 
@@ -517,7 +517,7 @@ void RDBController::parseDisplay(char *buf, char * expr)
     varTree_->viewport()->setUpdatesEnabled(false);
     varTree_->watchRoot()->setWatchExpression(buf, expr);
     varTree_->viewport()->setUpdatesEnabled(true);
-    varTree_->repaint();
+    varTree_->tqrepaint();
 }
 
 // **************************************************************************
@@ -538,7 +538,7 @@ void RDBController::parseUpdateDisplay(char *buf)
 	}
 
     varTree_->viewport()->setUpdatesEnabled(true);
-    varTree_->repaint();
+    varTree_->tqrepaint();
 }
 
 // **************************************************************************
@@ -549,7 +549,7 @@ void RDBController::parseGlobals(char *buf)
     varTree_->viewport()->setUpdatesEnabled(false);
     varTree_->globalRoot()->setGlobals(buf);
     varTree_->viewport()->setUpdatesEnabled(true);
-    varTree_->repaint();
+    varTree_->tqrepaint();
 }
 
 // **************************************************************************
@@ -584,7 +584,7 @@ void RDBController::parseLocals(char type, char *buf)
 	}
 
     varTree_->viewport()->setUpdatesEnabled(true);
-    varTree_->repaint();
+    varTree_->tqrepaint();
 }
 
 
@@ -601,27 +601,27 @@ void RDBController::parse(char *buf)
         parseProgramLocation(buf);
 	} else if (currentCmd_->rawDbgCommand() == "break") {
         emit rawRDBBreakpointList(buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "break ", strlen("break ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "break ", strlen("break ")) == 0) {
 		parseBreakpointSet(buf); 
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "watch ", strlen("watch ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "watch ", strlen("watch ")) == 0) {
 		parseBreakpointSet(buf); 
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "display ", strlen("display ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "display ", strlen("display ")) == 0) {
 		parseDisplay(buf, currentCmd_->rawDbgCommand().data() + strlen("display "));
 	} else if (currentCmd_->rawDbgCommand() == "display") {
 		parseUpdateDisplay(buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "undisplay ", strlen("undisplay ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "undisplay ", strlen("undisplay ")) == 0) {
 		;
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "method instance ", strlen("method instance ")) == 0) { 
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "method ", strlen("method ")) == 0) {
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "pp ", strlen("pp ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "method instance ", strlen("method instance ")) == 0) { 
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "method ", strlen("method ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "pp ", strlen("pp ")) == 0) {
 		parseRequestedData(buf);
 	} else if (currentCmd_->rawDbgCommand() == "thread list") {
 		parseThreadList(buf);
-	} else if (	qstrncmp(currentCmd_->rawDbgCommand(), "up ", strlen("up ")) == 0
-				|| qstrncmp(currentCmd_->rawDbgCommand(), "down ", strlen("down ")) == 0 ) 
+	} else if (	tqstrncmp(currentCmd_->rawDbgCommand(), "up ", strlen("up ")) == 0
+				|| tqstrncmp(currentCmd_->rawDbgCommand(), "down ", strlen("down ")) == 0 ) 
 	{
 		parseFrameMove(buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "thread switch ", strlen("thread switch ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "thread switch ", strlen("thread switch ")) == 0) {
 		parseSwitchThread(buf);
 	} else if (currentCmd_->rawDbgCommand() == "thread current") {
 		parseThreadList(buf);
@@ -631,11 +631,11 @@ void RDBController::parse(char *buf)
 		parseGlobals(buf);
 	} else if (currentCmd_->rawDbgCommand() == "var local") {
 		parseLocals(LOCALS, buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var instance ", strlen("var instance ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "var instance ", strlen("var instance ")) == 0) {
 		parseLocals(IVARS, buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var class ", strlen("var class ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "var class ", strlen("var class ")) == 0) {
 		parseLocals(CVARS, buf);
-	} else if (qstrncmp(currentCmd_->rawDbgCommand(), "var const ", strlen("var const ")) == 0) {
+	} else if (tqstrncmp(currentCmd_->rawDbgCommand(), "var const ", strlen("var const ")) == 0) {
 		parseLocals(CONSTANTS, buf);
 	}
 
@@ -766,9 +766,9 @@ void RDBController::slotStart(const TQString& ruby_interpreter, const TQString&
     // BUT the app hasn't been started yet! A run command is about to be issued
     // by whoever is controlling us.
 	
-    if (!dbgProcess_->writeStdin(TQString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
+    if (!dbgProcess_->writeStdin(TQString("%1\n").tqarg(unixSocketPath_.data()).latin1(), strlen(unixSocketPath_) + 1)) {
         kdDebug(9012) << "failed to write Unix domain socket path to rdb " 
-		<< TQString("%1\n").arg(unixSocketPath_).latin1() << endl;
+		<< TQString("%1\n").tqarg(unixSocketPath_.data()).latin1() << endl;
 	}
 	
 	setStateOff(s_programExited);
@@ -797,7 +797,7 @@ void RDBController::slotStopDebugger()
         start = TQTime::currentTime();
         while (-1)
         {
-            kapp->processEvents(20);
+            kapp->tqprocessEvents(20);
             now = TQTime::currentTime();
             if (!stateIsOn(s_appBusy) || start.msecsTo( now ) > 2000)
                 break;
@@ -816,7 +816,7 @@ void RDBController::slotStopDebugger()
     start = TQTime::currentTime();
     while (-1)
     {
-         kapp->processEvents(20);
+         kapp->tqprocessEvents(20);
          now = TQTime::currentTime();
          if (stateIsOn(s_programExited) || start.msecsTo( now ) > 2000)
              break;
@@ -833,7 +833,7 @@ void RDBController::slotStopDebugger()
     delete tty_;           tty_ = 0;
 
     state_ = s_dbgNotStarted | s_appNotStarted | s_silent;
-    emit dbgStatus (i18n("Debugger stopped"), state_);
+    emit dbgtqStatus (i18n("Debugger stopped"), state_);
 }
 
 
@@ -1175,7 +1175,7 @@ void RDBController::slotDbgWroteStdin(KProcess *)
 {
 //    setStateOff(s_waitForWrite);
     //  if (!stateIsOn(s_silent))
-    //    emit dbgStatus ("", state_);
+    //    emit dbgtqStatus ("", state_);
 //    executeCmd();
 }
 
@@ -1203,7 +1203,7 @@ void RDBController::slotAcceptConnection(int masterSocket)
                           this, TQT_SLOT(slotReadFromSocket(int)) );	
     
 	setStateOff(s_dbgNotStarted);
-    emit dbgStatus ("", state_);
+    emit dbgtqStatus ("", state_);
     
 	cmdList_.clear();
 	rdbOutputLen_ = 0;	
@@ -1283,7 +1283,7 @@ void RDBController::slotDbgProcessExited(KProcess*)
 {
     destroyCmds();
     state_ = s_appNotStarted|s_programExited|(state_&(s_shuttingDown));
-    emit dbgStatus (i18n("Process exited"), state_);
+    emit dbgtqStatus (i18n("Process exited"), state_);
     emit rdbStdout("(rdb:1) Process exited\n");
 	frameStack_->clear();
 	varTree_->clear();	
diff --git a/languages/ruby/debugger/rdbcontroller.h b/languages/ruby/debugger/rdbcontroller.h
index e2ed0746..af72ddbc 100644
--- a/languages/ruby/debugger/rdbcontroller.h
+++ b/languages/ruby/debugger/rdbcontroller.h
@@ -56,6 +56,7 @@ class STTY;
 class RDBController : public DbgController
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
     RDBController(VariableTree *varTree, FramestackWidget *frameStack, TQDomDocument &projectDom);
@@ -116,7 +117,7 @@ public slots:
     void slotBPState( const Breakpoint& );
     void slotClearAllBreakpoints();
 
-    void slotExpandItem(VarItem *parent, const TQCString &userRequest);
+    void slotExpandItem(VarItem *tqparent, const TQCString &userRequest);
     void slotRubyInspect(const TQString &inspectText);
     void slotSelectFrame(int frameNo, int threadNo, const TQString& frameName);
     void slotFetchGlobals(bool fetch);
diff --git a/languages/ruby/debugger/rdboutputwidget.cpp b/languages/ruby/debugger/rdboutputwidget.cpp
index 6eef01c7..b1b9deda 100644
--- a/languages/ruby/debugger/rdboutputwidget.cpp
+++ b/languages/ruby/debugger/rdboutputwidget.cpp
@@ -44,8 +44,8 @@ namespace RDBDebugger
 
 /***************************************************************************/
 
-RDBOutputWidget::RDBOutputWidget( TQWidget *parent, const char *name) :
-    TQWidget(parent, name),
+RDBOutputWidget::RDBOutputWidget( TQWidget *tqparent, const char *name) :
+    TQWidget(tqparent, name),
     m_userRDBCmdEditor(0),
     m_Interrupt(0),
     m_rdbView(0)
@@ -65,7 +65,7 @@ RDBOutputWidget::RDBOutputWidget( TQWidget *parent, const char *name) :
     userRDBCmdEntry->setStretchFactor(m_userRDBCmdEditor, 1);
 
     m_Interrupt = new TQToolButton( this, "add breakpoint" );
-    m_Interrupt->setSizePolicy ( TQSizePolicy ( (TQSizePolicy::SizeType)0,
+    m_Interrupt->tqsetSizePolicy ( TQSizePolicy ( (TQSizePolicy::SizeType)0,
                                          ( TQSizePolicy::SizeType)0,
                                          0,
                                          0,
@@ -79,7 +79,7 @@ RDBOutputWidget::RDBOutputWidget( TQWidget *parent, const char *name) :
     topLayout->addWidget(m_rdbView, 10);
     topLayout->addLayout(userRDBCmdEntry);
 
-    slotDbgStatus( "", s_dbgNotStarted);
+    slotDbgtqStatus( "", s_dbgNotStarted);
 
     connect( m_userRDBCmdEditor, TQT_SIGNAL(returnPressed()), TQT_SLOT(slotRDBCmd()) );
     connect( m_Interrupt,        TQT_SIGNAL(clicked()),       TQT_SIGNAL(breakInto()));
@@ -133,7 +133,7 @@ void RDBOutputWidget::slotRDBCmd()
 
 /***************************************************************************/
 
-void RDBOutputWidget::slotDbgStatus(const TQString &, int statusFlag)
+void RDBOutputWidget::slotDbgtqStatus(const TQString &, int statusFlag)
 {
     if (statusFlag & s_dbgNotStarted)
     {
diff --git a/languages/ruby/debugger/rdboutputwidget.h b/languages/ruby/debugger/rdboutputwidget.h
index 41d25e5d..32d53110 100644
--- a/languages/ruby/debugger/rdboutputwidget.h
+++ b/languages/ruby/debugger/rdboutputwidget.h
@@ -34,12 +34,13 @@ class TQToolButton;
 namespace RDBDebugger
 {
 
-class RDBOutputWidget : public QWidget
+class RDBOutputWidget : public TQWidget
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    RDBOutputWidget( TQWidget *parent=0, const char *name=0 );
+    RDBOutputWidget( TQWidget *tqparent=0, const char *name=0 );
     ~RDBOutputWidget();
 
     void clear();
@@ -47,7 +48,7 @@ public:
 public slots:
     void slotReceivedStdout(const char* line);
     void slotReceivedStderr(const char* line);
-    void slotDbgStatus     (const TQString &status, int statusFlag);
+    void slotDbgtqStatus     (const TQString &status, int statusFlag);
 
     void slotRDBCmd();
 
diff --git a/languages/ruby/debugger/rdbparser.cpp b/languages/ruby/debugger/rdbparser.cpp
index c1cd7717..dc7e0226 100644
--- a/languages/ruby/debugger/rdbparser.cpp
+++ b/languages/ruby/debugger/rdbparser.cpp
@@ -34,15 +34,15 @@ namespace RDBDebugger
 
 // **************************************************************************
 
-void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
+void RDBParser::parseVariables(LazyFetchItem *tqparent, char *buf)
 {
     static const char *unknown = "?";
 	
-	QString		varName;
-	QCString	value;
+	TQString		varName;
+	TQCString	value;
 	int			pos;
 
-    Q_ASSERT(parent);
+    Q_ASSERT(tqparent);
     if (buf == 0 || strlen(buf) == 0) {
         return;
 	}
@@ -64,10 +64,10 @@ void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
 		while (pos != -1) {
 			varName = var_re.cap(1);
 			if (ref_re.search(var_re.cap(2)) != -1) {
-				if (var_re.cap(2).contains("=") > 0) {
+				if (var_re.cap(2).tqcontains("=") > 0) {
 					value = (ref_re.cap(1) + ">").latin1();
 				} else {
-					// There are no 'name=value' pairs, as in #<Qt::Color:0x0 #ff0000>
+					// There are no 'name=value' pairs, as in #<TQt::Color:0x0 #ff0000>
 					value = var_re.cap(2).latin1();
 				}
 			} else if (struct_re.search(var_re.cap(2)) != -1) {
@@ -84,7 +84,7 @@ void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
 				dataType = VALUE_TYPE;
 			}
 			
-			setItem(parent, varName, dataType, value);
+			setItem(tqparent, varName, dataType, value);
 			
 			pos  += var_re.matchedLength();
 			pos = var_re.search(buf, pos);
@@ -94,15 +94,15 @@ void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
 	}
 }
 
-void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
+void RDBParser::parseExpandedVariable(VarItem *tqparent, char *buf)
 {
 	DataType	dataType;
 	int			pos;
-	QString		varName;
-	QCString	value;
+	TQString		varName;
+	TQCString	value;
 	TQRegExp 	ppref_re("(#<([^:]|::)+:0x[\\da-f]+)([^\\n>]*)(>?)");
     
-	switch (parent->dataType()) {
+	switch (tqparent->dataType()) {
     case REFERENCE_TYPE:
 	{
 		// Look for a reference type which has been printed via a 'pp' command, to
@@ -128,10 +128,10 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 				varName = ppvalue_re.cap(1);
 				
 				if (ppref_re.search(ppvalue_re.cap(2)) != -1) {
-					if (ppvalue_re.cap(2).contains("=") > 0) {
+					if (ppvalue_re.cap(2).tqcontains("=") > 0) {
 						value = (ppref_re.cap(1) + ">").latin1();
 					} else {
-						// There are no 'name=value' pairs, as in #<Qt::Color:0x0 #ff0000>
+						// There are no 'name=value' pairs, as in #<TQt::Color:0x0 #ff0000>
 						value = ppvalue_re.cap(2).latin1();
 					}
 				} else {
@@ -139,7 +139,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 				}
 				
 				dataType = determineType((char *) ppvalue_re.cap(2).latin1());
-				setItem(parent, varName, dataType, value);
+				setItem(tqparent, varName, dataType, value);
 				
 				pos += ppvalue_re.matchedLength();
 				pos = ppvalue_re.search(buf, pos);
@@ -170,7 +170,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 			}
 				
 			DataType dataType = determineType((char *) pparray_re.cap(2).latin1());
-			setItem(parent, varName, dataType, value);
+			setItem(tqparent, varName, dataType, value);
 				
 			pos += pparray_re.matchedLength();
 			pos = pparray_re.search(buf, pos);
@@ -193,7 +193,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 			varName = pphash_re.cap(1);
 			value = pphash_re.cap(2).latin1();
 	        DataType dataType = determineType(value.data());
-			setItem(parent, varName, dataType, value);
+			setItem(tqparent, varName, dataType, value);
 			
 			pos += pphash_re.matchedLength();
 			pos = pphash_re.search(buf, pos);
@@ -235,7 +235,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 				varName = ppvalue_re.cap(1);
 				value = ppvalue_re.cap(2).latin1();
 				dataType = determineType(value.data());
-				setItem(parent, varName, dataType, value);
+				setItem(tqparent, varName, dataType, value);
 				
 				pos += ppvalue_re.matchedLength();
 				pos = ppvalue_re.search(buf, pos);
@@ -259,7 +259,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 			varName = ppstring_re.cap(1);
 			value = ppstring_re.cap(2).latin1();
 	        DataType dataType = determineType(value.data());
-			setItem(parent, varName, dataType, value);
+			setItem(tqparent, varName, dataType, value);
 			
 			pos += ppstring_re.matchedLength();
 			pos = ppstring_re.search(buf, pos);
@@ -278,12 +278,12 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 
 // **************************************************************************
 
-void RDBParser::setItem(LazyFetchItem *parent, const TQString &varName,
+void RDBParser::setItem(LazyFetchItem *tqparent, const TQString &varName,
                         DataType dataType, const TQCString &value)
 {
-	VarItem *item = parent->findItem(varName);
+	VarItem *item = tqparent->findItem(varName);
     if (item == 0) {
-        item = new VarItem(parent, varName, dataType);
+        item = new VarItem(tqparent, varName, dataType);
     } else {
 		// The dataType of an item can change, so update it
 		item->setDataType(dataType);
@@ -319,11 +319,11 @@ DataType RDBParser::determineType(char *buf)
 	TQRegExp hash_re("(Hash \\(\\d+ element\\(s\\)\\))");
 	TQRegExp string_re("(String \\(length \\d+\\))");
 	
-	if (qstrncmp(buf, "#<struct", strlen("#<struct")) == 0) {
+	if (tqstrncmp(buf, "#<struct", strlen("#<struct")) == 0) {
 		return STRUCT_TYPE;
-	} else if (qstrncmp(buf, "#<Qt::Color:0x", strlen("#<Qt::Color:0x")) == 0) {
+	} else if (tqstrncmp(buf, "#<TQt::Color:0x", strlen("#<TQt::Color:0x")) == 0) {
 		return COLOR_TYPE;
-	} else if (qstrncmp(buf, "#<", strlen("#<")) == 0 && strstr(buf, "=") != 0) {
+	} else if (tqstrncmp(buf, "#<", strlen("#<")) == 0 && strstr(buf, "=") != 0) {
 		// An object instance reference is only expandable and a 'REFERENCE_TYPE'
 		// if it contains an '=' (ie it has at least one '@instance_variable=value').
 		// Otherwise, treat it as a 'VALUE_TYPE'.
@@ -334,7 +334,7 @@ DataType RDBParser::determineType(char *buf)
 		return HASH_TYPE;
 	} else if (string_re.search(buf) != -1) {
 		return STRING_TYPE;
-	} else if (qstrncmp(buf, "nil", strlen("nil")) == 0) {
+	} else if (tqstrncmp(buf, "nil", strlen("nil")) == 0) {
 //		return UNKNOWN_TYPE;
 		return VALUE_TYPE;
 	} else {
diff --git a/languages/ruby/debugger/rdbparser.h b/languages/ruby/debugger/rdbparser.h
index d57e25d7..2ee59b0a 100644
--- a/languages/ruby/debugger/rdbparser.h
+++ b/languages/ruby/debugger/rdbparser.h
@@ -29,10 +29,10 @@ namespace RDBDebugger
 
 namespace RDBParser
 {
-    void parseVariables(LazyFetchItem *parent, char *buf);
-    void parseExpandedVariable(VarItem *parent, char *buf);
+    void parseVariables(LazyFetchItem *tqparent, char *buf);
+    void parseExpandedVariable(VarItem *tqparent, char *buf);
     DataType determineType(char *buf);
-    void setItem(	LazyFetchItem *parent, const TQString &varName, 
+    void setItem(	LazyFetchItem *tqparent, const TQString &varName, 
 					DataType dataType, const TQCString &value );
 }
 
diff --git a/languages/ruby/debugger/rdbtable.cpp b/languages/ruby/debugger/rdbtable.cpp
index 31b7b6d2..429654d5 100644
--- a/languages/ruby/debugger/rdbtable.cpp
+++ b/languages/ruby/debugger/rdbtable.cpp
@@ -18,13 +18,13 @@
 
 namespace RDBDebugger {
 
-RDBTable::RDBTable(TQWidget *parent, const char *name)
- : TQTable(parent, name)
+RDBTable::RDBTable(TQWidget *tqparent, const char *name)
+ : TQTable(tqparent, name)
 {
 }
 
-RDBTable::RDBTable(int nr, int nc, TQWidget * parent, const char * name)
- : TQTable(nr, nc, parent, name)
+RDBTable::RDBTable(int nr, int nc, TQWidget * tqparent, const char * name)
+ : TQTable(nr, nc, tqparent, name)
 {
 }
 
diff --git a/languages/ruby/debugger/rdbtable.h b/languages/ruby/debugger/rdbtable.h
index 714605d0..5cb72e93 100644
--- a/languages/ruby/debugger/rdbtable.h
+++ b/languages/ruby/debugger/rdbtable.h
@@ -20,12 +20,13 @@
 
 namespace RDBDebugger {
 
-class RDBTable : public QTable
+class RDBTable : public TQTable
 {
 Q_OBJECT
+  TQ_OBJECT
 public:
-    RDBTable(TQWidget *parent = 0, const char *name = 0);
-    RDBTable( int numRows, int numCols, TQWidget * parent = 0, const char * name = 0 );
+    RDBTable(TQWidget *tqparent = 0, const char *name = 0);
+    RDBTable( int numRows, int numCols, TQWidget * tqparent = 0, const char * name = 0 );
     ~RDBTable();
 
     virtual void keyPressEvent ( TQKeyEvent * e );
diff --git a/languages/ruby/debugger/stty.cpp b/languages/ruby/debugger/stty.cpp
index bfdb5bd3..7381ae2a 100644
--- a/languages/ruby/debugger/stty.cpp
+++ b/languages/ruby/debugger/stty.cpp
@@ -104,7 +104,7 @@ static int chownpty(int fd, int grant)
 
         //    { // signal from other child, behave like catchChild.
         //      // guess this gives quite some control chaos...
-        //      Shell* sh = shells.find(rc);
+        //      Shell* sh = shells.tqfind(rc);
         //      if (sh) { shells.remove(rc); sh->doneShell(w); }
         //      goto retry;
         //    }
@@ -305,7 +305,7 @@ bool STTY::findExternalTTY(const TQString &termApp)
         const char* prog      = appName.latin1();
         TQString script = TQString("tty>") + TQString(fifo) +
             TQString(";"                  // fifo name
-                    "trap \"\" INT QUIT TSTP;"	  // ignore various signals
+                    "trap \"\" INT TQUIT TSTP;"	  // ignore various signals
                     "exec<&-;exec>&-;"		        // close stdin and stdout
                     "while :;do sleep 3600;done");
         const char* scriptStr = script.latin1();
@@ -330,11 +330,11 @@ bool STTY::findExternalTTY(const TQString &termApp)
         ::exit(1);
     }
 
-    // parent process
+    // tqparent process
     if (pid <= 0)
         ::exit(1);
 
-    // Open the communication between us (the parent) and the
+    // Open the communication between us (the tqparent) and the
     // child (the process running on a tty console)
     fifo_fd = ::open(fifo, O_RDONLY);
     if (fifo_fd < 0)
diff --git a/languages/ruby/debugger/stty.h b/languages/ruby/debugger/stty.h
index 20aece2c..d49e79f8 100644
--- a/languages/ruby/debugger/stty.h
+++ b/languages/ruby/debugger/stty.h
@@ -33,9 +33,10 @@ class TQSocketNotifier;
 namespace RDBDebugger
 {
 
-class STTY : public QObject
+class STTY : public TQObject
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
     STTY(bool ext=false, const TQString &termAppName=TQString());
diff --git a/languages/ruby/debugger/variablewidget.cpp b/languages/ruby/debugger/variablewidget.cpp
index fd323fd5..32b5d1ef 100644
--- a/languages/ruby/debugger/variablewidget.cpp
+++ b/languages/ruby/debugger/variablewidget.cpp
@@ -49,8 +49,8 @@
 namespace RDBDebugger
 {
 
-VariableWidget::VariableWidget(TQWidget *parent, const char *name)
-    : TQWidget(parent, name)
+VariableWidget::VariableWidget(TQWidget *tqparent, const char *name)
+    : TQWidget(tqparent, name)
 {
     varTree_ = new VariableTree(this);
     TQLabel *label = new TQLabel(i18n("E&xpression to watch:"), this);
@@ -81,8 +81,8 @@ VariableWidget::VariableWidget(TQWidget *parent, const char *name)
 void VariableWidget::setEnabled(bool bEnabled)
 {
     TQWidget::setEnabled(bEnabled);
-    if (bEnabled && parentWidget() != 0) {
-        varTree_->setColumnWidth(0, parentWidget()->width()/2);
+    if (bEnabled && tqparentWidget() != 0) {
+        varTree_->setColumnWidth(0, tqparentWidget()->width()/2);
 	}
 }
 // **************************************************************************
@@ -127,8 +127,8 @@ void VariableWidget::savePartialProjectSession(TQDomElement* el)
 // **************************************************************************
 // **************************************************************************
 
-VariableTree::VariableTree(VariableWidget *parent, const char *name)
-    : KListView(parent, name),
+VariableTree::VariableTree(VariableWidget *tqparent, const char *name)
+    : KListView(tqparent, name),
       TQToolTip( viewport() ),
       activationId_(0),
       currentThread_(-1),
@@ -187,7 +187,7 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
 
     setSelected(item, true);    // Need to select this item.
 
-    if (item->parent() != 0) {
+    if (item->tqparent() != 0) {
         KPopupMenu popup(this);
         popup.insertTitle(item->text(VAR_NAME_COLUMN));
         int idRemoveWatch = -2;
@@ -202,11 +202,11 @@ void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
 			emit removeWatchExpression(((WatchVarItem*)item)->displayId());
             delete item;
         } else if (res == idCopyToClipboard) {
-            QClipboard *qb = KApplication::clipboard();
+            TQClipboard *qb = KApplication::tqclipboard();
             TQString text = "{ \"" + item->text( VAR_NAME_COLUMN ) + "\", " +
                             "\"" + item->text( VALUE_COLUMN ) + "\" }";
 
-            qb->setText( text, QClipboard::Clipboard );
+            qb->setText( text, TQClipboard::Clipboard );
         }
     }
 }
@@ -233,7 +233,7 @@ void VariableTree::slotPressed(TQListViewItem * item)
 	}
 	
 	while (item->rtti() == RTTI_VAR_ITEM) {
-		item = item->parent();
+		item = item->tqparent();
 	}
 	
 	if (	item->rtti() == RTTI_GLOBAL_ROOT
@@ -280,7 +280,7 @@ void VariableTree::prune()
 
 // **************************************************************************
 
-// The debugger has moved onto the next program pause, so invalidate 
+// The debugger has moved onto the next program pause, so tqinvalidate 
 // everything in the Variable Tree
 void VariableTree::nextActivationId() 
 { 
@@ -329,7 +329,7 @@ bool VariableTree::schedule()
 			
 			if (frame->needsVariables()) {
 				if (TQApplication::overrideCursor() == 0) {
-					TQApplication::setOverrideCursor(TQCursor(Qt::WaitCursor));
+					TQApplication::setOverrideCursor(TQCursor(TQt::WaitCursor));
 				}
 				
 				// Tell the controller to fetch the variable values
@@ -428,7 +428,7 @@ void VariableTree::maybeTip(const TQPoint &p)
 {
     VarItem * item = dynamic_cast<VarItem*>( itemAt(p) );
     if (item != 0) {
-        TQRect r = itemRect(item);
+        TQRect r = tqitemRect(item);
         if (r.isValid()) {
             tip(r, item->tipText());
 		}
@@ -440,8 +440,8 @@ void VariableTree::maybeTip(const TQPoint &p)
 // **************************************************************************
 // **************************************************************************
 
-LazyFetchItem::LazyFetchItem(VariableTree *parent)
-    : KListViewItem(parent),
+LazyFetchItem::LazyFetchItem(VariableTree *tqparent)
+    : KListViewItem(tqparent),
       activationId_(0),
 	  waitingForData_(false)
 {
@@ -450,8 +450,8 @@ LazyFetchItem::LazyFetchItem(VariableTree *parent)
 
 // **************************************************************************
 
-LazyFetchItem::LazyFetchItem(LazyFetchItem *parent)
-    : KListViewItem(parent),
+LazyFetchItem::LazyFetchItem(LazyFetchItem *tqparent)
+    : KListViewItem(tqparent),
       activationId_(0),
       waitingForData_(false)
 {
@@ -474,7 +474,7 @@ void LazyFetchItem::paintCell(TQPainter *p, const TQColorGroup &cg,
 	}
 	
     // make toplevel item (watch and frame items) names bold
-    if (column == VAR_NAME_COLUMN && parent() == 0) {
+    if (column == VAR_NAME_COLUMN && tqparent() == 0) {
         TQFont f = p->font();
         f.setBold(true);
         p->setFont(f);
@@ -526,8 +526,8 @@ void LazyFetchItem::prune()
 // **************************************************************************
 // **************************************************************************
 
-VarItem::VarItem(LazyFetchItem *parent, const TQString &varName, DataType dataType)
-    : LazyFetchItem (parent),
+VarItem::VarItem(LazyFetchItem *tqparent, const TQString &varName, DataType dataType)
+    : LazyFetchItem (tqparent),
       cache_(TQCString()),
       dataType_(dataType),
       highlight_(false)
@@ -586,7 +586,7 @@ TQString VarItem::fullName() const
     TQString vPath("");
     const VarItem *item = this;
 
-	if (item->parent()->rtti() != RTTI_VAR_ITEM) {
+	if (item->tqparent()->rtti() != RTTI_VAR_ITEM) {
 		return itemName;
 	}
 
@@ -605,17 +605,17 @@ TQString VarItem::fullName() const
  				vPath.prepend(itemName + ".");
 			}
         }
-		item = (VarItem*) item->parent();
+		item = (VarItem*) item->tqparent();
     }
 
 	// Change 'self.@foobar' to '@foobar'
-	vPath.replace(TQRegExp("^self\\.@"), "@");
+	vPath.tqreplace(TQRegExp("^self\\.@"), "@");
 	
 	// Use instance_variable_get() to access any '@var's in the middle of a path	
 	TQRegExp re_instance_var("\\.(@[^\\[.]+)");
 	int pos = re_instance_var.search(vPath);	
 	while (pos != -1) {	
-		vPath.replace(	pos, 
+		vPath.tqreplace(	pos, 
 						re_instance_var.matchedLength(), 
 						TQString(".instance_variable_get(:") + re_instance_var.cap(1) + ")" );
 		pos = re_instance_var.search(vPath, pos);	
@@ -635,7 +635,7 @@ void VarItem::setText(int column, const TQString &data)
     }
 
     TQListViewItem::setText(column, data);
-    repaint();
+    tqrepaint();
 }
 
 // **************************************************************************
@@ -746,8 +746,8 @@ TQString VarItem::tipText() const
 // **************************************************************************
 // **************************************************************************
 
-VarFrameRoot::VarFrameRoot(VariableTree *parent, int frameNo, int threadNo)
-    : LazyFetchItem(parent),
+VarFrameRoot::VarFrameRoot(VariableTree *tqparent, int frameNo, int threadNo)
+    : LazyFetchItem(tqparent),
       needsVariables_(true),
       frameNo_(frameNo),
       threadNo_(threadNo),
@@ -816,7 +816,7 @@ void VarFrameRoot::setActivationId()
 	
 bool VarFrameRoot::needsVariables() const 
 { 
-	return (	text(VAR_NAME_COLUMN).contains("try_initialize") == 0 
+	return (	text(VAR_NAME_COLUMN).tqcontains("try_initialize") == 0 
 				&& isOpen() 
 				&& !isWaitingForData() 
 				&& needsVariables_ ); 
@@ -828,8 +828,8 @@ bool VarFrameRoot::needsVariables() const
 // **************************************************************************
 
 
-GlobalRoot::GlobalRoot(VariableTree *parent)
-    : LazyFetchItem(parent)
+GlobalRoot::GlobalRoot(VariableTree *tqparent)
+    : LazyFetchItem(tqparent)
 {
     setText(0, i18n("Global"));
     setExpandable(true);
@@ -872,8 +872,8 @@ void GlobalRoot::setOpen(bool open)
 // **************************************************************************
 // **************************************************************************
 
-WatchVarItem::WatchVarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType, int displayId )
-    : VarItem(parent, varName, dataType),
+WatchVarItem::WatchVarItem( LazyFetchItem *tqparent, const TQString &varName, DataType dataType, int displayId )
+    : VarItem(tqparent, varName, dataType),
 	displayId_(displayId)
 {
 }
@@ -903,8 +903,8 @@ int WatchVarItem::displayId()
 // **************************************************************************
 // **************************************************************************
 
-WatchRoot::WatchRoot(VariableTree *parent)
-    : LazyFetchItem(parent)
+WatchRoot::WatchRoot(VariableTree *tqparent)
+    : LazyFetchItem(tqparent)
 {
     setText(VAR_NAME_COLUMN, i18n("Watch"));
     setOpen(true);
diff --git a/languages/ruby/debugger/variablewidget.h b/languages/ruby/debugger/variablewidget.h
index 4104ae93..830acf64 100644
--- a/languages/ruby/debugger/variablewidget.h
+++ b/languages/ruby/debugger/variablewidget.h
@@ -60,12 +60,13 @@ enum DataType {
 	STRING_TYPE
 };		   
 
-class VariableWidget : public QWidget
+class VariableWidget : public TQWidget
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
-    VariableWidget( TQWidget *parent=0, const char *name=0 );
+    VariableWidget( TQWidget *tqparent=0, const char *name=0 );
 
     VariableTree *varTree() const
     { return varTree_; }
@@ -91,14 +92,15 @@ private:
 /***************************************************************************/
 /***************************************************************************/
 
-class VariableTree : public KListView, public QToolTip
+class VariableTree : public KListView, public TQToolTip
 {
     Q_OBJECT
+  TQ_OBJECT
 //we need this to be able to emit expandItem() from within LazyFetchItem
 friend class LazyFetchItem;
 
 public:
-	VariableTree( VariableWidget *parent, const char *name=0 );
+	VariableTree( VariableWidget *tqparent, const char *name=0 );
     virtual ~VariableTree();
 	
 	// Clear everything but the Watch frame
@@ -170,8 +172,8 @@ private:
 class LazyFetchItem : public KListViewItem
 {
 public:
-    LazyFetchItem(VariableTree *parent);
-    LazyFetchItem(LazyFetchItem *parent);
+    LazyFetchItem(VariableTree *tqparent);
+    LazyFetchItem(LazyFetchItem *tqparent);
 
     virtual ~LazyFetchItem();
 
@@ -204,7 +206,7 @@ private:
 class VarItem : public LazyFetchItem
 {
 public:
-    VarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType );
+    VarItem( LazyFetchItem *tqparent, const TQString &varName, DataType dataType );
 
     virtual ~VarItem();
 	
@@ -247,7 +249,7 @@ private:
 class WatchVarItem : public VarItem
 {
 public:
-    WatchVarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType, int displayId = -1);
+    WatchVarItem( LazyFetchItem *tqparent, const TQString &varName, DataType dataType, int displayId = -1);
 
     virtual ~WatchVarItem();
 	
@@ -268,13 +270,13 @@ private:
 class VarFrameRoot : public LazyFetchItem
 {
 public:
-    VarFrameRoot(VariableTree *parent, int frame, int thread);
+    VarFrameRoot(VariableTree *tqparent, int frame, int thread);
     virtual ~VarFrameRoot();
 	
 	virtual int rtti() const { return RTTI_VAR_FRAME_ROOT; }
 	
 	virtual TQString key(int column, bool /*ascending*/) const {
-		return TQString("%1%2").arg(RTTI_VAR_FRAME_ROOT).arg(text(column));
+		return TQString("%1%2").tqarg(RTTI_VAR_FRAME_ROOT).tqarg(text(column));
 	}
 
     void addLocals(char *variables);
@@ -303,13 +305,13 @@ private:
 class WatchRoot : public LazyFetchItem
 {
 public:
-    WatchRoot(VariableTree * parent);
+    WatchRoot(VariableTree * tqparent);
     virtual ~WatchRoot();
 	
 	virtual int rtti() const { return RTTI_WATCH_ROOT; }
 	
 	virtual TQString key(int column, bool /*ascending*/) const {
-		return TQString("%1%2").arg(RTTI_WATCH_ROOT).arg(text(column));
+		return TQString("%1%2").tqarg(RTTI_WATCH_ROOT).tqarg(text(column));
 	}
 
 	void setWatchExpression(char * buf, char * expr);
@@ -326,13 +328,13 @@ public:
 class GlobalRoot : public LazyFetchItem
 {
 public:
-    GlobalRoot(VariableTree * parent);
+    GlobalRoot(VariableTree * tqparent);
     virtual ~GlobalRoot();
 	
 	virtual int rtti() const { return RTTI_GLOBAL_ROOT; }
 	
 	virtual TQString key(int column, bool /*ascending*/) const {
-		return TQString("%1%2").arg(RTTI_GLOBAL_ROOT).arg(text(column));
+		return TQString("%1%2").tqarg(RTTI_GLOBAL_ROOT).tqarg(text(column));
 	}
 	
     void setOpen(bool open);