Trinity Qt initial conversion

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

29 files changed, 876 insertions, 876 deletions

diff --git a/languages/ruby/debugger/breakpoint.cpp b/languages/ruby/debugger/breakpoint.cpp
index f210e359..c9a91ec4 100644
--- a/languages/ruby/debugger/breakpoint.cpp
+++ b/languages/ruby/debugger/breakpoint.cpp
@@ -23,11 +23,11 @@
 
 #include <klocale.h>
 
-#include <qfileinfo.h>
-#include <qfontmetrics.h>
-#include <qpainter.h>
-#include <qregexp.h>
-#include <qstring.h>
+#include <tqfileinfo.h>
+#include <tqfontmetrics.h>
+#include <tqpainter.h>
+#include <tqregexp.h>
+#include <tqstring.h>
 
 #include <stdio.h>
 
@@ -67,12 +67,12 @@ Breakpoint::~Breakpoint()
 
 /***************************************************************************/
 
-QString Breakpoint::dbgRemoveCommand() const
+TQString Breakpoint::dbgRemoveCommand() const
 {
 //    if (dbgId_>0)
-//        return QString("delete %1").arg(dbgId_); // gdb command - not translatable
+//        return TQString("delete %1").arg(dbgId_); // gdb command - not translatable
 
-    return QString();
+    return TQString();
 }
 
 /***************************************************************************/
@@ -115,9 +115,9 @@ void Breakpoint::setActive(int active, int id)
 
 /***************************************************************************/
 
-QString Breakpoint::statusDisplay(int activeFlag) const
+TQString Breakpoint::statusDisplay(int activeFlag) const
 {
-    QString status="";
+    TQString status="";
     if (!s_enabled_)
         status = i18n("Disabled");
     else
@@ -141,7 +141,7 @@ QString Breakpoint::statusDisplay(int activeFlag) const
 /***************************************************************************/
 /***************************************************************************/
 
-FilePosBreakpoint::FilePosBreakpoint(const QString &fileName, int lineNum,
+FilePosBreakpoint::FilePosBreakpoint(const TQString &fileName, int lineNum,
                                      bool temporary, bool enabled)
     : Breakpoint(temporary, enabled),
       fileName_(fileName),
@@ -157,13 +157,13 @@ FilePosBreakpoint::~FilePosBreakpoint()
 
 /***************************************************************************/
 
-QString FilePosBreakpoint::dbgSetCommand() const
+TQString FilePosBreakpoint::dbgSetCommand() const
 {
-    QString cmdStr;
+    TQString cmdStr;
     if (fileName_.isEmpty())
-        cmdStr = QString("break %1").arg(lineNo_);  // gdb command - not translatable
+        cmdStr = TQString("break %1").arg(lineNo_);  // gdb command - not translatable
     else {
-        cmdStr = QString("break %1:%2").arg(fileName_).arg(lineNo_);
+        cmdStr = TQString("break %1:%2").arg(fileName_).arg(lineNo_);
     }
 
     if (isTemporary())
@@ -192,26 +192,26 @@ bool FilePosBreakpoint::match(const Breakpoint *brkpt) const
 
 /***************************************************************************/
 
-QString FilePosBreakpoint::location(bool compact)
+TQString FilePosBreakpoint::location(bool compact)
 {
     if (compact)
-        return QFileInfo(fileName_).fileName()+":"+QString::number(lineNo_);
+        return TQFileInfo(fileName_).fileName()+":"+TQString::number(lineNo_);
 
-    return fileName_+":"+QString::number(lineNo_);
+    return fileName_+":"+TQString::number(lineNo_);
 }
 
 /***************************************************************************/
 
-void FilePosBreakpoint::setLocation(const QString& location)
+void FilePosBreakpoint::setLocation(const TQString& location)
 {
-    QRegExp regExp1("(.*):(\\d+)$");
+    TQRegExp regExp1("(.*):(\\d+)$");
     regExp1.setMinimal(true);
     if ( regExp1.search(location, 0) >= 0 )
     {
-        QString t = regExp1.cap(1);
-        QString dirPath = QFileInfo(t).dirPath();
+        TQString t = regExp1.cap(1);
+        TQString dirPath = TQFileInfo(t).dirPath();
         if ( dirPath == "." )
-            fileName_ = QFileInfo(fileName_).dirPath()+"/"+regExp1.cap(1);
+            fileName_ = TQFileInfo(fileName_).dirPath()+"/"+regExp1.cap(1);
         else
             fileName_ = regExp1.cap(1);
 
@@ -223,7 +223,7 @@ void FilePosBreakpoint::setLocation(const QString& location)
 /***************************************************************************/
 /***************************************************************************/
 
-Watchpoint::Watchpoint(const QString& varName, bool temporary, bool enabled)
+Watchpoint::Watchpoint(const TQString& varName, bool temporary, bool enabled)
     : Breakpoint(temporary, enabled),
       varName_(varName)
 {
@@ -237,9 +237,9 @@ Watchpoint::~Watchpoint()
 
 /***************************************************************************/
 
-QString Watchpoint::dbgSetCommand() const
+TQString Watchpoint::dbgSetCommand() const
 {
-    return QString("watch ")+varName_;    // gdb command - not translatable
+    return TQString("watch ")+varName_;    // gdb command - not translatable
 }
 
 /***************************************************************************/
@@ -263,7 +263,7 @@ bool Watchpoint::match(const Breakpoint* brkpt) const
 /***************************************************************************/
 /***************************************************************************/
 
-Catchpoint::Catchpoint(const QString& varName, bool temporary, bool enabled)
+Catchpoint::Catchpoint(const TQString& varName, bool temporary, bool enabled)
     : Breakpoint(temporary, enabled),
       varName_(varName)
 {
@@ -277,9 +277,9 @@ Catchpoint::~Catchpoint()
 
 /***************************************************************************/
 
-QString Catchpoint::dbgSetCommand() const
+TQString Catchpoint::dbgSetCommand() const
 {
-    return QString("catch ")+varName_;    // gdb command - not translatable
+    return TQString("catch ")+varName_;    // gdb command - not translatable
 }
 
 /***************************************************************************/
@@ -303,7 +303,7 @@ bool Catchpoint::match(const Breakpoint* brkpt) const
 /***************************************************************************/
 /***************************************************************************/
 
-FunctionBreakpoint::FunctionBreakpoint(const QString& functionName, bool temporary, bool enabled)
+FunctionBreakpoint::FunctionBreakpoint(const TQString& functionName, bool temporary, bool enabled)
     : Breakpoint(temporary, enabled),
       m_functionName(functionName)
 {
@@ -317,9 +317,9 @@ FunctionBreakpoint::~FunctionBreakpoint()
 
 /***************************************************************************/
 
-QString FunctionBreakpoint::dbgSetCommand() const
+TQString FunctionBreakpoint::dbgSetCommand() const
 {
-    return QString("break ")+m_functionName;    // gdb command - not translatable
+    return TQString("break ")+m_functionName;    // gdb command - not translatable
 }
 
 /***************************************************************************/
diff --git a/languages/ruby/debugger/breakpoint.h b/languages/ruby/debugger/breakpoint.h
index e45e3856..91f1c8db 100644
--- a/languages/ruby/debugger/breakpoint.h
+++ b/languages/ruby/debugger/breakpoint.h
@@ -24,7 +24,7 @@
 
 #include <klocale.h>
 
-#include <qstring.h>
+#include <tqstring.h>
 
 /***************************************************************************/
 /***************************************************************************/
@@ -48,8 +48,8 @@ public:
     Breakpoint(bool temporary=false, bool enabled=true);
     virtual ~Breakpoint();
 
-    virtual QString dbgSetCommand() const                 = 0;
-    virtual QString dbgRemoveCommand() const;
+    virtual TQString dbgSetCommand() const                 = 0;
+    virtual TQString dbgRemoveCommand() const;
     virtual bool match(const Breakpoint* brkpt) const     = 0;
     virtual void reset();
 
@@ -84,12 +84,12 @@ public:
     void setDbgId(int dbgId)                        { dbgId_ = dbgId; }
     int  dbgId() const                              { return dbgId_; }
 
-    virtual QString statusDisplay(int activeFlag) const;
+    virtual TQString statusDisplay(int activeFlag) const;
     virtual BP_TYPES type() const                   { return BP_TYPE_Invalid; }
-    virtual QString displayType() const             { return i18n( "Invalid" ); }
+    virtual TQString displayType() const             { return i18n( "Invalid" ); }
 
-    virtual QString location(bool compact=true)     = 0;
-    virtual void setLocation(const QString& )       = 0;
+    virtual TQString location(bool compact=true)     = 0;
+    virtual void setLocation(const TQString& )       = 0;
     virtual bool isValid() const                    = 0;
 
 private:
@@ -109,8 +109,8 @@ private:
     int active_;                        // counter incremented on receipt of all BP's
 
     int ignoreCount_;
-    QString condition_;
-//    QString type_;
+    TQString condition_;
+//    TQString type_;
 };
 
 /***************************************************************************/
@@ -119,24 +119,24 @@ private:
 class FilePosBreakpoint : public Breakpoint
 {
 public:
-    FilePosBreakpoint(const QString &fileName, int lineNum,
+    FilePosBreakpoint(const TQString &fileName, int lineNum,
                       bool temporary=false, bool enabled=true);
     virtual ~FilePosBreakpoint();
-    virtual QString dbgSetCommand() const;
+    virtual TQString dbgSetCommand() const;
     virtual bool match(const Breakpoint *brkpt) const;
 
     BP_TYPES type () const                      { return BP_TYPE_FilePos; }
-    QString displayType() const                 { return i18n( "File:line" ); }
-    void setFileName(const QString& fileName)   { fileName_ = fileName; }
-    QString fileName() const                    { return fileName_; }
+    TQString displayType() const                 { return i18n( "File:line" ); }
+    void setFileName(const TQString& fileName)   { fileName_ = fileName; }
+    TQString fileName() const                    { return fileName_; }
     void setLineNum(int lineNum)                { lineNo_ = lineNum; }
     int lineNum() const                         { return lineNo_; }
-    QString location(bool compact=true);
-    void setLocation(const QString& location);
+    TQString location(bool compact=true);
+    void setLocation(const TQString& location);
     bool isValid() const                        { return lineNo_>0 && !fileName_.isEmpty(); }
 
 private:
-    QString fileName_;
+    TQString fileName_;
     int lineNo_;
 };
 
@@ -146,21 +146,21 @@ private:
 class Watchpoint : public Breakpoint
 {
 public:
-    Watchpoint(const QString &varName, bool temporary=false, bool enabled=true);
+    Watchpoint(const TQString &varName, bool temporary=false, bool enabled=true);
     virtual ~Watchpoint();
-    virtual QString dbgSetCommand() const;
+    virtual TQString dbgSetCommand() const;
     bool match(const Breakpoint *brkpt) const;
 
     BP_TYPES type () const                      { return BP_TYPE_Watchpoint; }
-    QString displayType() const                 { return i18n("Watchpoint"); }
-    void setVarName(const QString& varName)     { varName_ = varName; }
-    QString varName() const                     { return varName_; }
-    QString location(bool)                      { return varName_; }
-    void setLocation(const QString& location)   { varName_ = location; }
+    TQString displayType() const                 { return i18n("Watchpoint"); }
+    void setVarName(const TQString& varName)     { varName_ = varName; }
+    TQString varName() const                     { return varName_; }
+    TQString location(bool)                      { return varName_; }
+    void setLocation(const TQString& location)   { varName_ = location; }
     bool isValid() const                        { return !varName_.isEmpty(); }
 
 private:
-    QString varName_;
+    TQString varName_;
 };
 
 /***************************************************************************/
@@ -169,21 +169,21 @@ private:
 class Catchpoint : public Breakpoint
 {
 public:
-    Catchpoint(const QString &varName, bool temporary=false, bool enabled=true);
+    Catchpoint(const TQString &varName, bool temporary=false, bool enabled=true);
     virtual ~Catchpoint();
-    virtual QString dbgSetCommand() const;
+    virtual TQString dbgSetCommand() const;
     bool match(const Breakpoint *brkpt) const;
 
     BP_TYPES type () const                      { return BP_TYPE_Catchpoint; }
-    QString displayType() const                 { return i18n("Catchpoint"); }
-    void setVarName(const QString& varName)     { varName_ = varName; }
-    QString varName() const                     { return varName_; }
-    QString location(bool)                      { return varName_; }
-    void setLocation(const QString& location)   { varName_ = location; }
+    TQString displayType() const                 { return i18n("Catchpoint"); }
+    void setVarName(const TQString& varName)     { varName_ = varName; }
+    TQString varName() const                     { return varName_; }
+    TQString location(bool)                      { return varName_; }
+    void setLocation(const TQString& location)   { varName_ = location; }
     bool isValid() const                        { return !varName_.isEmpty(); }
 
 private:
-    QString varName_;
+    TQString varName_;
 };
 
 /***************************************************************************/
@@ -192,21 +192,21 @@ private:
 class FunctionBreakpoint : public Breakpoint
 {
 public:
-    FunctionBreakpoint(const QString &functionName, bool temporary=false, bool enabled=true);
+    FunctionBreakpoint(const TQString &functionName, bool temporary=false, bool enabled=true);
     virtual ~FunctionBreakpoint();
-    virtual QString dbgSetCommand() const;
+    virtual TQString dbgSetCommand() const;
     bool match(const Breakpoint *brkpt) const;
 
     BP_TYPES type () const                              { return BP_TYPE_Function; }
-    QString displayType() const                         { return i18n("Method()"); }
-    void setfunctionName(const QString& functionName)   { m_functionName = functionName; }
-    QString functionName() const                        { return m_functionName; }
-    QString location(bool)                              { return m_functionName; };
-    void setLocation(const QString& location)           { m_functionName = location; }
+    TQString displayType() const                         { return i18n("Method()"); }
+    void setfunctionName(const TQString& functionName)   { m_functionName = functionName; }
+    TQString functionName() const                        { return m_functionName; }
+    TQString location(bool)                              { return m_functionName; };
+    void setLocation(const TQString& location)           { m_functionName = location; }
     bool isValid() const                                { return !m_functionName.isEmpty(); }
 
 private:
-    QString m_functionName;
+    TQString m_functionName;
 };
 
 }
diff --git a/languages/ruby/debugger/dbgcommand.cpp b/languages/ruby/debugger/dbgcommand.cpp
index 6c6a24ec..7d958091 100644
--- a/languages/ruby/debugger/dbgcommand.cpp
+++ b/languages/ruby/debugger/dbgcommand.cpp
@@ -21,7 +21,7 @@
 
 #include "dbgcommand.h"
 
-#include <qstring.h>
+#include <tqstring.h>
 
 /***************************************************************************/
 /***************************************************************************/
@@ -30,7 +30,7 @@ namespace RDBDebugger
 {
 
 
-DbgCommand::DbgCommand(const QCString& command, bool isRunCmd, bool isInfoCmd) :
+DbgCommand::DbgCommand(const TQCString& command, bool isRunCmd, bool isInfoCmd) :
   command_(command),
   isRunCmd_(isRunCmd),
   isInfoCmd_(isInfoCmd),
diff --git a/languages/ruby/debugger/dbgcommand.h b/languages/ruby/debugger/dbgcommand.h
index 32ec7f7a..6cea2afb 100644
--- a/languages/ruby/debugger/dbgcommand.h
+++ b/languages/ruby/debugger/dbgcommand.h
@@ -22,7 +22,7 @@
 #ifndef DBGCOMMAND_H
 #define DBGCOMMAND_H
 
-#include <qstring.h>
+#include <tqstring.h>
 
 /**
  * @author John Birch
@@ -34,21 +34,21 @@ namespace RDBDebugger
 class DbgCommand
 {
 public:
-    DbgCommand(const QCString& command, bool isRunCmd, bool isInfoCmd);
+    DbgCommand(const TQCString& command, bool isRunCmd, bool isInfoCmd);
     virtual ~DbgCommand() {};
 
-    virtual QCString& cmdToSend()             { sent_ = true;  return cmdBuffer_; }
+    virtual TQCString& cmdToSend()             { sent_ = true;  return cmdBuffer_; }
     virtual int cmdLength()                   { return cmdBuffer_.length(); }
 
-    QCString rawDbgCommand() const            { return command_; }
+    TQCString rawDbgCommand() const            { return command_; }
     bool isARunCmd() const                    { return isRunCmd_;}
     bool isAnInfoCmd() const                  { return isInfoCmd_; }
     bool moreToSend() const                   { return !sent_; }
     bool expectReply() const                  { return waitForReply_; }
 
 protected:
-    QCString cmdBuffer_;
-    QCString command_;
+    TQCString cmdBuffer_;
+    TQCString command_;
     bool    isRunCmd_;
     bool    isInfoCmd_;
     bool    sent_;
diff --git a/languages/ruby/debugger/dbgcontroller.h b/languages/ruby/debugger/dbgcontroller.h
index 13ee4382..f0b08981 100644
--- a/languages/ruby/debugger/dbgcontroller.h
+++ b/languages/ruby/debugger/dbgcontroller.h
@@ -22,7 +22,7 @@
 #ifndef _DBGCONTROLLER_H_
 #define _DBGCONTROLLER_H_
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <domutil.h>
 
 class KProcess;
@@ -105,19 +105,19 @@ public slots:
      * \param run_arguments Command line arguments to be passed to the application
      * \param show_constants Show ruby constants in the variables view
      */
-    virtual void slotStart(const QString& ruby_interpreter,
-	                       const QString& character_coding,
-                           const QString& run_directory,
-						   const QString& debuggee_path,
-                           const QString& application,
-                           const QString& run_arguments,
+    virtual void slotStart(const TQString& ruby_interpreter,
+	                       const TQString& character_coding,
+                           const TQString& run_directory,
+						   const TQString& debuggee_path,
+                           const TQString& application,
+                           const TQString& run_arguments,
                            bool show_constants,
                            bool trace_into_ruby)                            = 0;
 
     virtual void slotStopDebugger()                                         = 0;
 
     virtual void slotRun()                                                  = 0;
-    virtual void slotRunUntil(const QString &fileName, int lineNum)         = 0;
+    virtual void slotRunUntil(const TQString &fileName, int lineNum)         = 0;
     virtual void slotStepInto()                                             = 0;
     virtual void slotStepOver()                                             = 0;
     virtual void slotStepOutOff()                                           = 0;
@@ -127,9 +127,9 @@ public slots:
 
 
     virtual void slotExpandItem(VarItem *parent,
-                                    const QCString &userRequest)            = 0;
+                                    const TQCString &userRequest)            = 0;
     virtual void slotSelectFrame(int frame, int thread, 
-	                                const QString& frameName)               = 0;
+	                                const TQString& frameName)               = 0;
     virtual void slotFetchGlobals(bool fetch)                               = 0;
 
 protected slots:
@@ -142,15 +142,15 @@ protected slots:
     virtual void slotReadFromSocket(int socket)                             = 0;
 
 signals:
-    void gotoSourcePosition   (const QString &fileName, int lineNum);
+    void gotoSourcePosition   (const TQString &fileName, int lineNum);
     void rawRDBBreakpointList (char *buf);
     void rawRDBBreakpointSet  (char *buf, int key);
     void ttyStdout            (const char *output);
     void ttyStderr            (const char *output);
     void rdbStdout            (const char *output);
     void rdbStderr            (const char *output);
-    void showStepInSource     (const QString &fileName, int lineNum, const QString &address);
-    void dbgStatus            (const QString &status, int statusFlag);
+    void showStepInSource     (const TQString &fileName, int lineNum, const TQString &address);
+    void dbgStatus            (const TQString &status, int statusFlag);
 
 protected:
     KProcess *dbgProcess_;
diff --git a/languages/ruby/debugger/dbgpsdlg.cpp b/languages/ruby/debugger/dbgpsdlg.cpp
index 83dd1666..d5458c28 100644
--- a/languages/ruby/debugger/dbgpsdlg.cpp
+++ b/languages/ruby/debugger/dbgpsdlg.cpp
@@ -29,12 +29,12 @@
 #include <kstdguiitem.h>
 #include <kdeversion.h>
 
-#include <qframe.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlistbox.h>
-#include <qtoolbutton.h>
-#include <qpushbutton.h>
+#include <tqframe.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqlistbox.h>
+#include <tqtoolbutton.h>
+#include <tqpushbutton.h>
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -51,19 +51,19 @@ 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(QWidget *parent, const char *name)
+Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *parent, const char *name)
     : KDialog(parent, name, true),      // modal
       psProc_(0),
-      pids_(new QListBox(this)),
-      heading_(new QLabel(" ", this)),
-      pidLines_(QString())
+      pids_(new TQListBox(this)),
+      heading_(new TQLabel(" ", this)),
+      pidLines_(TQString())
 {
     setCaption(i18n("Attach to Process"));
 
-    QBoxLayout *topLayout = new QVBoxLayout(this, 5);
+    TQBoxLayout *topLayout = new TQVBoxLayout(this, 5);
 
     heading_->setFont(KGlobalSettings::fixedFont());
-    heading_->setFrameStyle(QFrame::Panel|QFrame::Sunken);
+    heading_->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
     heading_->setMaximumHeight(heading_->sizeHint().height());
 //    heading_->setMinimumSize(heading_->sizeHint());
     topLayout->addWidget(heading_, 5);
@@ -72,14 +72,14 @@ Dbg_PS_Dialog::Dbg_PS_Dialog(QWidget *parent, const char *name)
     pids_->setFont(KGlobalSettings::fixedFont());
 
     KButtonBox *buttonbox = new KButtonBox(this, Qt::Horizontal, 5);
-    QPushButton *ok       = buttonbox->addButton(KStdGuiItem::ok());
+    TQPushButton *ok       = buttonbox->addButton(KStdGuiItem::ok());
     buttonbox->addStretch();
-    QPushButton *cancel   = buttonbox->addButton(KStdGuiItem::cancel());
+    TQPushButton *cancel   = buttonbox->addButton(KStdGuiItem::cancel());
     buttonbox->layout();
     topLayout->addWidget(buttonbox);
 
-    connect(ok,     SIGNAL(clicked()),  SLOT(accept()));
-    connect(cancel, SIGNAL(clicked()),  SLOT(reject()));
+    connect(ok,     TQT_SIGNAL(clicked()),  TQT_SLOT(accept()));
+    connect(cancel, TQT_SIGNAL(clicked()),  TQT_SLOT(reject()));
 
     psProc_ = new KShellProcess("/bin/sh");
     #ifdef USE_SOLARIS
@@ -106,8 +106,8 @@ Dbg_PS_Dialog::Dbg_PS_Dialog(QWidget *parent, const char *name)
     }
     #endif
 
-    connect( psProc_, SIGNAL(processExited(KProcess *)),                SLOT(slotProcessExited()) );
-    connect( psProc_, SIGNAL(receivedStdout(KProcess *, char *, int)),  SLOT(slotReceivedOutput(KProcess *, char *, int)) );
+    connect( psProc_, TQT_SIGNAL(processExited(KProcess *)),                TQT_SLOT(slotProcessExited()) );
+    connect( psProc_, TQT_SIGNAL(receivedStdout(KProcess *, char *, int)),  TQT_SLOT(slotReceivedOutput(KProcess *, char *, int)) );
     psProc_->start(KProcess::NotifyOnExit, KProcess::Stdout);
 
     // Default display to 40 chars wide, default height is okay
@@ -126,7 +126,7 @@ Dbg_PS_Dialog::~Dbg_PS_Dialog()
 
 int Dbg_PS_Dialog::pidSelected()
 {
-    QString pidText = pids_->text(pids_->currentItem());
+    TQString pidText = pids_->text(pids_->currentItem());
     if (!pidText.isEmpty())
         return atoi(pidText.latin1());
 
@@ -137,7 +137,7 @@ int Dbg_PS_Dialog::pidSelected()
 
 void Dbg_PS_Dialog::slotReceivedOutput(KProcess */*proc*/, char *buffer, int buflen)
 {
-    pidLines_ += QString::fromLocal8Bit(buffer, buflen+1);
+    pidLines_ += TQString::fromLocal8Bit(buffer, buflen+1);
 }
 
 /***************************************************************************/
@@ -154,7 +154,7 @@ void Dbg_PS_Dialog::slotProcessExited()
     if (start != -1)
         heading_->setText(pidLines_.left(start));
     while ( (pos = pidLines_.find('\n', start)) != -1) {
-        QString item = pidLines_.mid(start, pos-start);
+        TQString item = pidLines_.mid(start, pos-start);
         if (!item.isEmpty()) {
             if (item.find(pidCmd_) == -1)
                 pids_->insertItem(item);
diff --git a/languages/ruby/debugger/dbgpsdlg.h b/languages/ruby/debugger/dbgpsdlg.h
index 641f7aa5..e210c92b 100644
--- a/languages/ruby/debugger/dbgpsdlg.h
+++ b/languages/ruby/debugger/dbgpsdlg.h
@@ -38,7 +38,7 @@ class Dbg_PS_Dialog : public KDialog
     Q_OBJECT
 
 public:
-    Dbg_PS_Dialog( QWidget *parent=0, const char *name=0 );
+    Dbg_PS_Dialog( TQWidget *parent=0, const char *name=0 );
     ~Dbg_PS_Dialog();
 
     int pidSelected();
@@ -49,10 +49,10 @@ private slots:
 
 private:
     KProcess* psProc_;
-    QListBox* pids_;
-    QLabel*   heading_;
-    QString   pidLines_;
-    QString   pidCmd_;
+    TQListBox* pids_;
+    TQLabel*   heading_;
+    TQString   pidLines_;
+    TQString   pidCmd_;
 };
 
 }
diff --git a/languages/ruby/debugger/dbgtoolbar.cpp b/languages/ruby/debugger/dbgtoolbar.cpp
index 702c8e83..36b42f07 100644
--- a/languages/ruby/debugger/dbgtoolbar.cpp
+++ b/languages/ruby/debugger/dbgtoolbar.cpp
@@ -31,14 +31,14 @@
 #include <kwin.h>
 #include <kwinmodule.h>
 
-#include <qapplication.h>
-#include <qcursor.h>
-#include <qframe.h>
-#include <qlayout.h>
-#include <qpainter.h>
-#include <qpushbutton.h>
-#include <qtooltip.h>
-#include <qwhatsthis.h>
+#include <tqapplication.h>
+#include <tqcursor.h>
+#include <tqframe.h>
+#include <tqlayout.h>
+#include <tqpainter.h>
+#include <tqpushbutton.h>
+#include <tqtooltip.h>
+#include <tqwhatsthis.h>
 
 // **************************************************************************
 // **************************************************************************
@@ -77,25 +77,25 @@ public:
     DbgMoveHandle(DbgToolBar *parent=0, const char * name=0, WFlags f=0);
     virtual ~DbgMoveHandle();
 
-    virtual void mousePressEvent(QMouseEvent *e);
-    virtual void mouseReleaseEvent(QMouseEvent *e);
-    virtual void mouseMoveEvent(QMouseEvent *e);
+    virtual void mousePressEvent(TQMouseEvent *e);
+    virtual void mouseReleaseEvent(TQMouseEvent *e);
+    virtual void mouseMoveEvent(TQMouseEvent *e);
 
 private:
     DbgToolBar* toolBar_;
-    QPoint      offset_;
+    TQPoint      offset_;
     bool        moving_;
 };
 
 // **************************************************************************
 
 DbgMoveHandle::DbgMoveHandle(DbgToolBar *parent, const char * name, WFlags f)
-    : QFrame(parent, name, f),
+    : TQFrame(parent, name, f),
       toolBar_(parent),
-      offset_(QPoint(0,0)),
+      offset_(TQPoint(0,0)),
       moving_(false)
 {
-    setFrameStyle(QFrame::Panel|QFrame::Raised);
+    setFrameStyle(TQFrame::Panel|TQFrame::Raised);
     setFixedHeight(12);
 }
 
@@ -107,9 +107,9 @@ DbgMoveHandle::~DbgMoveHandle()
 
 // **************************************************************************
 
-void DbgMoveHandle::mousePressEvent(QMouseEvent *e)
+void DbgMoveHandle::mousePressEvent(TQMouseEvent *e)
 {
-    QFrame::mousePressEvent(e);
+    TQFrame::mousePressEvent(e);
     if (moving_)
         return;
 
@@ -117,38 +117,38 @@ void DbgMoveHandle::mousePressEvent(QMouseEvent *e)
         KPopupMenu *menu = new KPopupMenu(this);
 	menu->insertTitle(i18n("Debug Toolbar"));
         menu->insertItem(i18n("Dock to Panel"),
-                         parent(), SLOT(slotDock()));
+                         parent(), TQT_SLOT(slotDock()));
         menu->insertItem(i18n("Dock to Panel && Iconify KDevelop"),
-                         parent(), SLOT(slotIconifyAndDock()));
+                         parent(), TQT_SLOT(slotIconifyAndDock()));
         menu->popup(e->globalPos());
     } else {
         moving_ = true;
         offset_ = parentWidget()->pos() - e->globalPos();
-        setFrameStyle(QFrame::Panel|QFrame::Sunken);
-        QApplication::setOverrideCursor(QCursor(sizeAllCursor));
-        setPalette(QPalette(colorGroup().background()));
+        setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
+        TQApplication::setOverrideCursor(TQCursor(sizeAllCursor));
+        setPalette(TQPalette(colorGroup().background()));
         repaint();
     }
 }
 
 // **************************************************************************
 
-void DbgMoveHandle::mouseReleaseEvent(QMouseEvent *e)
+void DbgMoveHandle::mouseReleaseEvent(TQMouseEvent *e)
 {
-    QFrame::mouseReleaseEvent(e);
+    TQFrame::mouseReleaseEvent(e);
     moving_ = false;
-    offset_ = QPoint(0,0);
-    setFrameStyle(QFrame::Panel|QFrame::Raised);
-    QApplication::restoreOverrideCursor();
-    setPalette(QPalette(colorGroup().background()));
+    offset_ = TQPoint(0,0);
+    setFrameStyle(TQFrame::Panel|TQFrame::Raised);
+    TQApplication::restoreOverrideCursor();
+    setPalette(TQPalette(colorGroup().background()));
     repaint();
 }
 
 // **************************************************************************
 
-void DbgMoveHandle::mouseMoveEvent(QMouseEvent *e)
+void DbgMoveHandle::mouseMoveEvent(TQMouseEvent *e)
 {
-    QFrame::mouseMoveEvent(e);
+    TQFrame::mouseMoveEvent(e);
     if (!moving_)
         return;
 
@@ -164,21 +164,21 @@ void DbgMoveHandle::mouseMoveEvent(QMouseEvent *e)
 class DbgButton : public QPushButton
 {
 public:
-    DbgButton(const QPixmap &pixmap, const QString &text,
+    DbgButton(const TQPixmap &pixmap, const TQString &text,
               DbgToolBar *parent, const char *name=0);
     virtual ~DbgButton() {};
-    void drawButtonLabel(QPainter *painter);
-    QSize sizeHint() const;
+    void drawButtonLabel(TQPainter *painter);
+    TQSize sizeHint() const;
 
 private:
-    QPixmap pixmap_;
+    TQPixmap pixmap_;
 };
 
 // **************************************************************************
 
-DbgButton::DbgButton(const QPixmap& pixmap, const QString& text,
+DbgButton::DbgButton(const TQPixmap& pixmap, const TQString& text,
                      DbgToolBar* parent, const char* name)
-    : QPushButton(parent, name),
+    : TQPushButton(parent, name),
       pixmap_(pixmap)
 {
     setText(text);
@@ -186,7 +186,7 @@ DbgButton::DbgButton(const QPixmap& pixmap, const QString& text,
 
 // **************************************************************************
 
-void DbgButton::drawButtonLabel(QPainter *painter)
+void DbgButton::drawButtonLabel(TQPainter *painter)
 {
     // We always have a pixmap (today...)
     // Centre it if there's no text
@@ -204,29 +204,29 @@ void DbgButton::drawButtonLabel(QPainter *painter)
 
 // **************************************************************************
 
-QSize DbgButton::sizeHint() const
+TQSize DbgButton::sizeHint() const
 {
     if (text().isEmpty())
         return pixmap_.size();
     else
-        return QPushButton::sizeHint();
+        return TQPushButton::sizeHint();
 }
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
-DbgDocker::DbgDocker(QWidget* parent, DbgToolBar* toolBar, const QPixmap& pixmap) :
+DbgDocker::DbgDocker(TQWidget* parent, DbgToolBar* toolBar, const TQPixmap& pixmap) :
     KSystemTray(parent, "DbgDocker"),
     toolBar_(toolBar)
 {
     setPixmap(pixmap);
-    QToolTip::add( this, i18n("KDevelop ruby debugger: Click to execute one line of code (\"step\")") );
+    TQToolTip::add( this, i18n("KDevelop ruby debugger: Click to execute one line of code (\"step\")") );
 }
 
 // **************************************************************************
 
-void DbgDocker::mousePressEvent(QMouseEvent *e)
+void DbgDocker::mousePressEvent(TQMouseEvent *e)
 {
     if (!rect().contains( e->pos()))
         return;
@@ -242,8 +242,8 @@ void DbgDocker::mousePressEvent(QMouseEvent *e)
         {
             KPopupMenu* menu = new KPopupMenu(this);
 	    menu->insertTitle(i18n("Debug Toolbar"));
-            menu->insertItem(i18n("Activate"),                        toolBar_, SLOT(slotUndock()));
-            menu->insertItem(i18n("Activate (KDevelop gets focus)"),  toolBar_, SLOT(slotActivateAndUndock()));
+            menu->insertItem(i18n("Activate"),                        toolBar_, TQT_SLOT(slotUndock()));
+            menu->insertItem(i18n("Activate (KDevelop gets focus)"),  toolBar_, TQT_SLOT(slotActivateAndUndock()));
             menu->popup(e->globalPos());
             break;
         }
@@ -257,8 +257,8 @@ void DbgDocker::mousePressEvent(QMouseEvent *e)
 // **************************************************************************
 
 DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
-                       QWidget* parent, const char* name)
-    : QFrame(0, name),
+                       TQWidget* parent, const char* name)
+    : TQFrame(0, name),
       part_(part),
       activeWindow_(0),
       winModule_(0),
@@ -271,7 +271,7 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
 {
     winModule_  = new KWinModule(this);
     docker_ = new DbgDocker(parent, this, BarIcon("dbgnext"));
-    connect(docker_, SIGNAL(clicked()), part_, SLOT(slotStepOver()));
+    connect(docker_, TQT_SIGNAL(clicked()), part_, TQT_SLOT(slotStepOver()));
 
     // Must have noFocus set so that we can see what window was active.
     // see slotDbgKdevFocus() for more comments
@@ -285,55 +285,55 @@ DbgToolBar::DbgToolBar(RubyDebuggerPart* part,
     KWin::setType(winId(), NET::Dock);
 
     setFocusPolicy(NoFocus);
-    setFrameStyle( QFrame::Box | QFrame::Plain );
+    setFrameStyle( TQFrame::Box | TQFrame::Plain );
     setLineWidth(4);
     setMidLineWidth(0);
 
-    QBoxLayout* topLayout     = new QVBoxLayout(this);
+    TQBoxLayout* topLayout     = new TQVBoxLayout(this);
 
-    QBoxLayout* nextLayout    = new QHBoxLayout();
-    QBoxLayout* stepLayout    = new QHBoxLayout();
-    QBoxLayout* focusLayout   = new QHBoxLayout();
+    TQBoxLayout* nextLayout    = new TQHBoxLayout();
+    TQBoxLayout* stepLayout    = new TQHBoxLayout();
+    TQBoxLayout* focusLayout   = new TQHBoxLayout();
 
     DbgMoveHandle*  moveHandle= new DbgMoveHandle(this);
 
-    QPushButton*  bRun        = new DbgButton(BarIcon("dbgrun"),        i18n("Run"),        this);
-    QPushButton*  bInterrupt  = new DbgButton(BarIcon("player_pause"),  i18n("Interrupt"),  this);
-    QPushButton*  bNext       = new DbgButton(BarIcon("dbgnext"),       i18n("Step Over"),  this);
-    QPushButton*  bStep       = new DbgButton(BarIcon("dbgstep"),       i18n("Step Into"),    this);
-    QPushButton*  bFinish     = new DbgButton(BarIcon("dbgstepout"),    i18n("Step Out"),   this);
-    QPushButton*  bRunTo      = new DbgButton(BarIcon("dbgrunto"),      i18n("Run to Cursor"),   this);
-    bPrevFocus_ = new DbgButton(BarIcon("dbgmemview"),    QString::null,      this);
-    bKDevFocus_ = new DbgButton(BarIcon("kdevelop"),      QString::null,      this);
-
-  connect(bRun,        SIGNAL(clicked()), part_,  SLOT(slotRun()));
-  connect(bInterrupt,  SIGNAL(clicked()), part_,  SLOT(slotPause()));
-  connect(bNext,       SIGNAL(clicked()), part_,  SLOT(slotStepOver()));
-  connect(bStep,       SIGNAL(clicked()), part_,  SLOT(slotStepInto()));
-  connect(bFinish,     SIGNAL(clicked()), part_,  SLOT(slotStepOut()));
-  connect(bRunTo,      SIGNAL(clicked()), part_,  SLOT(slotRunToCursor()));
-  connect(bKDevFocus_, SIGNAL(clicked()), this,   SLOT(slotKdevFocus()));
-  connect(bPrevFocus_, SIGNAL(clicked()), this,   SLOT(slotPrevFocus()));
-
-    QToolTip::add( bRun,        i18n("Continue with application execution, may start the application") );
-    QToolTip::add( bInterrupt,  i18n("Interrupt the application execution") );
-    QToolTip::add( bNext,       i18n("Execute one line of code, but run through methods") );
-    QToolTip::add( bStep,       i18n("Execute one line of code, stepping into methods if appropriate") );
-    QToolTip::add( bFinish,     i18n("Execute to end of current stack frame") );
-    QToolTip::add( bRunTo,      i18n("Continues execution until the cursor position is reached.") );
-    QToolTip::add( bKDevFocus_, i18n("Set focus on KDevelop") );
-    QToolTip::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus") );
-
-    QWhatsThis::add( bRun,        i18n("Continue with application execution. May start the application.") );
-    QWhatsThis::add( bInterrupt,  i18n("Interrupt the application execution.") );
-    QWhatsThis::add( bNext,       i18n("Execute one line of code, but run through methods.") );
-
-    QWhatsThis::add( bStep,       i18n("Execute one line of code, stepping into methods if appropriate.") );
+    TQPushButton*  bRun        = new DbgButton(BarIcon("dbgrun"),        i18n("Run"),        this);
+    TQPushButton*  bInterrupt  = new DbgButton(BarIcon("player_pause"),  i18n("Interrupt"),  this);
+    TQPushButton*  bNext       = new DbgButton(BarIcon("dbgnext"),       i18n("Step Over"),  this);
+    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);
+
+  connect(bRun,        TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotRun()));
+  connect(bInterrupt,  TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotPause()));
+  connect(bNext,       TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepOver()));
+  connect(bStep,       TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepInto()));
+  connect(bFinish,     TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepOut()));
+  connect(bRunTo,      TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotRunToCursor()));
+  connect(bKDevFocus_, TQT_SIGNAL(clicked()), this,   TQT_SLOT(slotKdevFocus()));
+  connect(bPrevFocus_, TQT_SIGNAL(clicked()), this,   TQT_SLOT(slotPrevFocus()));
+
+    TQToolTip::add( bRun,        i18n("Continue with application execution, may start the application") );
+    TQToolTip::add( bInterrupt,  i18n("Interrupt the application execution") );
+    TQToolTip::add( bNext,       i18n("Execute one line of code, but run through methods") );
+    TQToolTip::add( bStep,       i18n("Execute one line of code, stepping into methods if appropriate") );
+    TQToolTip::add( bFinish,     i18n("Execute to end of current stack frame") );
+    TQToolTip::add( bRunTo,      i18n("Continues execution until the cursor position is reached.") );
+    TQToolTip::add( bKDevFocus_, i18n("Set focus on KDevelop") );
+    TQToolTip::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus") );
+
+    TQWhatsThis::add( bRun,        i18n("Continue with application execution. May start the application.") );
+    TQWhatsThis::add( bInterrupt,  i18n("Interrupt the application execution.") );
+    TQWhatsThis::add( bNext,       i18n("Execute one line of code, but run through methods.") );
+
+    TQWhatsThis::add( bStep,       i18n("Execute one line of code, stepping into methods if appropriate.") );
     
-    QWhatsThis::add( bFinish,     i18n("Execute to end of current stack frame.") );
-    QWhatsThis::add( bRunTo,      i18n("Continues execution until the cursor position is reached.") );
-    QWhatsThis::add( bKDevFocus_, i18n("Set focus on KDevelop.") );
-    QWhatsThis::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus.") );
+    TQWhatsThis::add( bFinish,     i18n("Execute to end of current stack frame.") );
+    TQWhatsThis::add( bRunTo,      i18n("Continues execution until the cursor position is reached.") );
+    TQWhatsThis::add( bKDevFocus_, i18n("Set focus on KDevelop.") );
+    TQWhatsThis::add( bPrevFocus_, i18n("Set focus on window that had focus when KDevelop got focus.") );
 
     topLayout->addWidget(moveHandle);
     topLayout->addWidget(bRun);
@@ -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 QString&, int state)
+void DbgToolBar::slotDbgStatus(const TQString&, int state)
 {
     bool appIndicator = state & s_appBusy;
     if (appIndicator != appIsActive_) {
@@ -421,11 +421,11 @@ void DbgToolBar::slotDbgStatus(const QString&, int state)
 void DbgToolBar::setAppIndicator(bool appIndicator)
 {
     if (appIndicator) {
-        bPrevFocus_->setPalette(QPalette(colorGroup().mid()));
-        bKDevFocus_->setPalette(QPalette(colorGroup().background()));
+        bPrevFocus_->setPalette(TQPalette(colorGroup().mid()));
+        bKDevFocus_->setPalette(TQPalette(colorGroup().background()));
     } else {
-        bPrevFocus_->setPalette(QPalette(colorGroup().background()));
-        bKDevFocus_->setPalette(QPalette(colorGroup().mid()));
+        bPrevFocus_->setPalette(TQPalette(colorGroup().background()));
+        bKDevFocus_->setPalette(TQPalette(colorGroup().mid()));
     }
 }
 
diff --git a/languages/ruby/debugger/dbgtoolbar.h b/languages/ruby/debugger/dbgtoolbar.h
index a19b2eae..a83c120a 100644
--- a/languages/ruby/debugger/dbgtoolbar.h
+++ b/languages/ruby/debugger/dbgtoolbar.h
@@ -27,7 +27,7 @@ class KWinModule;
 #include <ksystemtray.h>
 #include <kwin.h>         // needed for WId :(
 
-#include <qframe.h>
+#include <tqframe.h>
 
 namespace RDBDebugger
 {
@@ -41,9 +41,9 @@ class DbgDocker : public KSystemTray
     Q_OBJECT
 
 public:
-    DbgDocker(QWidget *parent, DbgToolBar *toolBar, const QPixmap &pixmap);
+    DbgDocker(TQWidget *parent, DbgToolBar *toolBar, const TQPixmap &pixmap);
     virtual ~DbgDocker()  {};
-    virtual void mousePressEvent(QMouseEvent *e);
+    virtual void mousePressEvent(TQMouseEvent *e);
 
 signals:
     void clicked();
@@ -58,11 +58,11 @@ class DbgToolBar : public QFrame
     Q_OBJECT
 
 public:
-    DbgToolBar(RubyDebuggerPart *part, QWidget* parent, const char* name=0);
+    DbgToolBar(RubyDebuggerPart *part, TQWidget* parent, const char* name=0);
     virtual ~DbgToolBar();
 
 private slots:
-    void slotDbgStatus(const QString&, int);
+    void slotDbgStatus(const TQString&, int);
     void slotDock();
     void slotUndock();
     void slotIconifyAndDock();
diff --git a/languages/ruby/debugger/debuggerpart.cpp b/languages/ruby/debugger/debuggerpart.cpp
index 95b4dd09..3e46a3d4 100644
--- a/languages/ruby/debugger/debuggerpart.cpp
+++ b/languages/ruby/debugger/debuggerpart.cpp
@@ -18,10 +18,10 @@
  ***************************************************************************/
 #include "debuggerpart.h"
 
-#include <qdir.h>
-#include <qvbox.h>
-#include <qwhatsthis.h>
-#include <qpopupmenu.h>
+#include <tqdir.h>
+#include <tqvbox.h>
+#include <tqwhatsthis.h>
+#include <tqpopupmenu.h>
 
 #include <kaction.h>
 #include <kdebug.h>
@@ -36,7 +36,7 @@
 #include <kmessagebox.h>
 #include <kapplication.h>
 #include <dcopclient.h>
-#include <qtimer.h>
+#include <tqtimer.h>
 #include <kstringhandler.h>
 #include <kstandarddirs.h>
 
@@ -72,7 +72,7 @@ static const KDevPluginInfo data("kdevrbdebugger");
 typedef KDevGenericFactory<RubyDebuggerPart> RubyDebuggerFactory;
 K_EXPORT_COMPONENT_FACTORY( libkdevrbdebugger, RubyDebuggerFactory( data ) )
 
-RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QStringList & ) :
+RubyDebuggerPart::RubyDebuggerPart( TQObject *parent, const char *name, const TQStringList & ) :
     KDevPlugin( &data, parent, name ? name : "RubyDebuggerPart" ),
     controller(0)
 {
@@ -83,7 +83,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
     m_debugger = new Debugger( partController() );
     
-	statusBarIndicator = new QLabel(" ", mainWindow()->statusBar());
+	statusBarIndicator = new TQLabel(" ", mainWindow()->statusBar());
     statusBarIndicator->setFixedWidth(15);
     mainWindow()->statusBar()->addWidget(statusBarIndicator, 0, true);
     statusBarIndicator->show();
@@ -93,7 +93,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 //     /*variableWidget*/->setEnabled(false);
     variableWidget->setIcon(SmallIcon("math_brace"));
     variableWidget->setCaption(i18n("Variable Tree"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (variableWidget, i18n("<b>Variable tree</b><p>"
                               "The variable tree allows you to see "
                               "the variable values as you step "
@@ -108,7 +108,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
     rdbBreakpointWidget = new RDBBreakpointWidget( 0, "rdbBreakpointWidget" );
     rdbBreakpointWidget->setCaption(i18n("Breakpoint List"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (rdbBreakpointWidget, i18n("<b>Breakpoint list</b><p>"
                                 "Displays a list of breakpoints with "
                                 "their current status. Clicking on a "
@@ -121,7 +121,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     framestackWidget = new FramestackWidget( 0, "rdbFramestackWidget" );
     framestackWidget->setEnabled(false);
     framestackWidget->setCaption(i18n("Frame Stack"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (framestackWidget, i18n("<b>Frame stack</b><p>"
                                 "Often referred to as the \"call stack\", "
                                 "this is a list showing what method is "
@@ -139,7 +139,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     rdbOutputWidget->setEnabled(false);
     rdbOutputWidget->setIcon( SmallIcon("inline_image") );
     rdbOutputWidget->setCaption(i18n("RDB Output"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (rdbOutputWidget, i18n("<b>RDB output</b><p>"
                                  "Shows all rdb commands being executed. "
                                  "You can also issue any other rdb command while debugging."));
@@ -148,19 +148,19 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     mainWindow()->setViewAvailable(rdbOutputWidget, false);
 
     // rdbBreakpointWidget -> this
-    connect( rdbBreakpointWidget, SIGNAL(refreshBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( rdbBreakpointWidget, SIGNAL(publishBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( rdbBreakpointWidget, SIGNAL(gotoSourcePosition(const QString&, int)),
-             this,             SLOT(slotGotoSource(const QString&, int)) );
+    connect( rdbBreakpointWidget, TQT_SIGNAL(refreshBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( rdbBreakpointWidget, TQT_SIGNAL(publishBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( rdbBreakpointWidget, TQT_SIGNAL(gotoSourcePosition(const TQString&, int)),
+             this,             TQT_SLOT(slotGotoSource(const TQString&, int)) );
 
     // Now setup the actions
     KAction *action;
 
 //    action = new KAction(i18n("&Start"), "1rightarrow", CTRL+SHIFT+Key_F9,
     action = new KAction(i18n("&Start"), "dbgrun", CTRL+SHIFT+Key_F9,
-                         this, SLOT(slotRun()),
+                         this, TQT_SLOT(slotRun()),
                          actionCollection(), "debug_run");
     action->setToolTip( i18n("Start in debugger") );
     action->setWhatsThis( i18n("<b>Start in debugger</b><p>"
@@ -171,26 +171,26 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
                                "about variables, frame stack, and so on.") );
 
     action = new KAction(i18n("Sto&p"), "stop", 0,
-                         this, SLOT(slotStop()),
+                         this, TQT_SLOT(slotStop()),
                          actionCollection(), "debug_stop");
     action->setToolTip( i18n("Stop debugger") );
     action->setWhatsThis(i18n("<b>Stop debugger</b><p>Kills the executable and exits the debugger."));
 
     action = new KAction(i18n("Interrupt"), "player_pause", 0,
-                         this, SLOT(slotPause()),
+                         this, TQT_SLOT(slotPause()),
                          actionCollection(), "debug_pause");
     action->setToolTip( i18n("Interrupt application") );
     action->setWhatsThis(i18n("<b>Interrupt application</b><p>Interrupts the debugged process or current RDB command."));
 
     action = new KAction(i18n("Run to &Cursor"), "dbgrunto", 0,
-                         this, SLOT(slotRunToCursor()),
+                         this, TQT_SLOT(slotRunToCursor()),
                          actionCollection(), "debug_runtocursor");
     action->setToolTip( i18n("Run to cursor") );
     action->setWhatsThis(i18n("<b>Run to cursor</b><p>Continues execution until the cursor position is reached."));
 
 
     action = new KAction(i18n("Step &Over"), "dbgnext", 0,
-                         this, SLOT(slotStepOver()),
+                         this, TQT_SLOT(slotStepOver()),
                          actionCollection(), "debug_stepover");
     action->setToolTip( i18n("Step over the next line") );
     action->setWhatsThis( i18n("<b>Step over</b><p>"
@@ -201,7 +201,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Step &Into"), "dbgstep", 0,
-                         this, SLOT(slotStepInto()),
+                         this, TQT_SLOT(slotStepInto()),
                          actionCollection(), "debug_stepinto");
     action->setToolTip( i18n("Step into the next statement") );
     action->setWhatsThis( i18n("<b>Step into</b><p>"
@@ -212,7 +212,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Step O&ut"), "dbgstepout", 0,
-                         this, SLOT(slotStepOut()),
+                         this, TQT_SLOT(slotStepOut()),
                          actionCollection(), "debug_stepout");
     action->setToolTip( i18n("Steps out of the current method") );
     action->setWhatsThis( i18n("<b>Step out</b><p>"
@@ -224,48 +224,48 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Toggle Breakpoint"), 0, 0,
-                         this, SLOT(toggleBreakpoint()),
+                         this, TQT_SLOT(toggleBreakpoint()),
                          actionCollection(), "debug_toggle_breakpoint");
     action->setToolTip(i18n("Toggle breakpoint"));
     action->setWhatsThis(i18n("<b>Toggle breakpoint</b><p>Toggles the breakpoint at the current line in editor."));
 
-    connect( mainWindow()->main()->guiFactory(), SIGNAL(clientAdded(KXMLGUIClient*)),
-             this, SLOT(guiClientAdded(KXMLGUIClient*)) );
+    connect( mainWindow()->main()->guiFactory(), TQT_SIGNAL(clientAdded(KXMLGUIClient*)),
+             this, TQT_SLOT(guiClientAdded(KXMLGUIClient*)) );
 
 
-    connect( partController(), SIGNAL(loadedFile(const KURL &)),
-             rdbBreakpointWidget, SLOT(slotRefreshBP(const KURL &)) );
-    connect( debugger(), SIGNAL(toggledBreakpoint(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotToggleBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(editedBreakpoint(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotEditBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(toggledBreakpointEnabled(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotToggleBreakpointEnabled(const QString &, int)) );
+    connect( partController(), TQT_SIGNAL(loadedFile(const KURL &)),
+             rdbBreakpointWidget, TQT_SLOT(slotRefreshBP(const KURL &)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpoint(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotToggleBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(editedBreakpoint(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotEditBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpointEnabled(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotToggleBreakpointEnabled(const TQString &, int)) );
 
-    connect( core(), SIGNAL(contextMenu(QPopupMenu *, const Context *)),
-             this, SLOT(contextMenu(QPopupMenu *, const Context *)) );
+    connect( core(), TQT_SIGNAL(contextMenu(TQPopupMenu *, const Context *)),
+             this, TQT_SLOT(contextMenu(TQPopupMenu *, const Context *)) );
 
-    connect( core(), SIGNAL(stopButtonClicked(KDevPlugin*)),
-             this, SLOT(slotStop(KDevPlugin*)) );
-    connect( core(), SIGNAL(projectClosed()),
-             this, SLOT(projectClosed()) );
+    connect( core(), TQT_SIGNAL(stopButtonClicked(KDevPlugin*)),
+             this, TQT_SLOT(slotStop(KDevPlugin*)) );
+    connect( core(), TQT_SIGNAL(projectClosed()),
+             this, TQT_SLOT(projectClosed()) );
 
-    connect( partController(), SIGNAL(activePartChanged(KParts::Part*)),
-             this, SLOT(slotActivePartChanged(KParts::Part*)) );
+    connect( partController(), TQT_SIGNAL(activePartChanged(KParts::Part*)),
+             this, TQT_SLOT(slotActivePartChanged(KParts::Part*)) );
 
     procLineMaker = new ProcessLineMaker();
 
-    connect( procLineMaker, SIGNAL(receivedStdoutLine(const QCString&)),
-             appFrontend(), SLOT(insertStdoutLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedStderrLine(const QCString&)),
-             appFrontend(), SLOT(insertStderrLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedPartialStdoutLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStdoutLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedPartialStderrLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStderrLine(const QCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedStdoutLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(insertStdoutLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedStderrLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(insertStderrLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedPartialStdoutLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(addPartialStdoutLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedPartialStderrLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(addPartialStderrLine(const TQCString&)) );
 
     setupController();
-    QTimer::singleShot(0, this, SLOT(setupDcop()));
+    TQTimer::singleShot(0, this, TQT_SLOT(setupDcop()));
 }
 
 RubyDebuggerPart::~RubyDebuggerPart()
@@ -297,10 +297,10 @@ void RubyDebuggerPart::guiClientAdded( KXMLGUIClient* client )
     // Can't change state until after XMLGUI has been loaded...
     // Anyone know of a better way of doing this?
     if( client == this )
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
 }
 
-void RubyDebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
+void RubyDebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
 {
     if (!context->hasType( Context::EditorContext ))
         return;
@@ -311,16 +311,16 @@ void RubyDebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
     popup->insertSeparator();
     if (econtext->url().isLocalFile())
     {
-        int id = popup->insertItem( i18n("Toggle Breakpoint"), this, SLOT(toggleBreakpoint()) );
+        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."));
     }
     if (!m_contextIdent.isEmpty())
     {
-        QString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
-        int id = popup->insertItem( i18n("Watch: %1").arg(squeezed), this, SLOT(contextWatch()) );
+        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."));
         
-		id = popup->insertItem( i18n("Inspect: %1").arg(squeezed), this, SLOT(contextRubyInspect()) );
+		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."));
     }
 }
@@ -362,86 +362,86 @@ void RubyDebuggerPart::setupController()
     controller = new RDBController(variableTree, framestackWidget, *projectDom());
 
     // this -> controller
-    connect( this,                  SIGNAL(rubyInspect(const QString&)),
-             controller,            SLOT(slotRubyInspect(const QString&)));
+    connect( this,                  TQT_SIGNAL(rubyInspect(const TQString&)),
+             controller,            TQT_SLOT(slotRubyInspect(const TQString&)));
 
     // variableTree -> framestackWidget
-    connect( variableTree,          SIGNAL(selectFrame(int, int)),
-             framestackWidget,      SLOT(slotSelectFrame(int, int)));
+    connect( variableTree,          TQT_SIGNAL(selectFrame(int, int)),
+             framestackWidget,      TQT_SLOT(slotSelectFrame(int, int)));
     
 	// framestackWidget -> variableTree
-    connect( framestackWidget,      SIGNAL(frameActive(int, int, const QString&)),
-             variableTree,          SLOT(slotFrameActive(int, int, const QString&)));
+    connect( framestackWidget,      TQT_SIGNAL(frameActive(int, int, const TQString&)),
+             variableTree,          TQT_SLOT(slotFrameActive(int, int, const TQString&)));
 	
     // variableTree -> controller
-    connect( variableTree,          SIGNAL(expandItem(VarItem*, const QCString&)),
-             controller,            SLOT(slotExpandItem(VarItem*, const QCString&)));
-    connect( variableTree,          SIGNAL(fetchGlobals(bool)),
-             controller,            SLOT(slotFetchGlobals(bool)));
-    connect( variableTree,          SIGNAL(addWatchExpression(const QString&, bool)),
-             controller,            SLOT(slotAddWatchExpression(const QString&, bool)));  
-    connect( variableTree,          SIGNAL(removeWatchExpression(int)),
-             controller,            SLOT(slotRemoveWatchExpression(int)));  
+    connect( variableTree,          TQT_SIGNAL(expandItem(VarItem*, const TQCString&)),
+             controller,            TQT_SLOT(slotExpandItem(VarItem*, const TQCString&)));
+    connect( variableTree,          TQT_SIGNAL(fetchGlobals(bool)),
+             controller,            TQT_SLOT(slotFetchGlobals(bool)));
+    connect( variableTree,          TQT_SIGNAL(addWatchExpression(const TQString&, bool)),
+             controller,            TQT_SLOT(slotAddWatchExpression(const TQString&, bool)));  
+    connect( variableTree,          TQT_SIGNAL(removeWatchExpression(int)),
+             controller,            TQT_SLOT(slotRemoveWatchExpression(int)));  
     
     // framestackWidget -> controller
-    connect( framestackWidget,      SIGNAL(selectFrame(int,int,const QString&)),
-             controller,            SLOT(slotSelectFrame(int,int,const QString&)));
+    connect( framestackWidget,      TQT_SIGNAL(selectFrame(int,int,const TQString&)),
+             controller,            TQT_SLOT(slotSelectFrame(int,int,const TQString&)));
 
     // rdbBreakpointWidget -> controller
-    connect( rdbBreakpointWidget,   SIGNAL(clearAllBreakpoints()),
-             controller,            SLOT(slotClearAllBreakpoints()));
-    connect( rdbBreakpointWidget,   SIGNAL(publishBPState(const Breakpoint&)),
-             controller,            SLOT(slotBPState(const Breakpoint &)));
+    connect( rdbBreakpointWidget,   TQT_SIGNAL(clearAllBreakpoints()),
+             controller,            TQT_SLOT(slotClearAllBreakpoints()));
+    connect( rdbBreakpointWidget,   TQT_SIGNAL(publishBPState(const Breakpoint&)),
+             controller,            TQT_SLOT(slotBPState(const Breakpoint &)));
 
 
     // rdbOutputWidget -> controller
-    connect( rdbOutputWidget,       SIGNAL(userRDBCmd(const QString &)),
-             controller,            SLOT(slotUserRDBCmd(const QString&)));
-    connect( rdbOutputWidget,       SIGNAL(breakInto()),
-             controller,            SLOT(slotBreakInto()));
+    connect( rdbOutputWidget,       TQT_SIGNAL(userRDBCmd(const TQString &)),
+             controller,            TQT_SLOT(slotUserRDBCmd(const TQString&)));
+    connect( rdbOutputWidget,       TQT_SIGNAL(breakInto()),
+             controller,            TQT_SLOT(slotBreakInto()));
 
     // controller -> rdbBreakpointWidget
-    connect( controller,            SIGNAL(acceptPendingBPs()),
-             rdbBreakpointWidget,   SLOT(slotSetPendingBPs()));
-    connect( controller,            SIGNAL(unableToSetBPNow(int)),
-             rdbBreakpointWidget,   SLOT(slotUnableToSetBPNow(int)));
-    connect( controller,            SIGNAL(rawRDBBreakpointList (char*)),
-             rdbBreakpointWidget,   SLOT(slotParseRDBBrkptList(char*)));
-    connect( controller,            SIGNAL(rawRDBBreakpointSet(char*, int)),
-             rdbBreakpointWidget,   SLOT(slotParseRDBBreakpointSet(char*, int)));
+    connect( controller,            TQT_SIGNAL(acceptPendingBPs()),
+             rdbBreakpointWidget,   TQT_SLOT(slotSetPendingBPs()));
+    connect( controller,            TQT_SIGNAL(unableToSetBPNow(int)),
+             rdbBreakpointWidget,   TQT_SLOT(slotUnableToSetBPNow(int)));
+    connect( controller,            TQT_SIGNAL(rawRDBBreakpointList (char*)),
+             rdbBreakpointWidget,   TQT_SLOT(slotParseRDBBrkptList(char*)));
+    connect( controller,            TQT_SIGNAL(rawRDBBreakpointSet(char*, int)),
+             rdbBreakpointWidget,   TQT_SLOT(slotParseRDBBreakpointSet(char*, int)));
 
 
     // controller -> this
-    connect( controller,            SIGNAL(dbgStatus(const QString&, int)),
-             this,                  SLOT(slotStatus(const QString&, int)));
-    connect( controller,            SIGNAL(showStepInSource(const QString&, int, const QString&)),
-             this,                  SLOT(slotShowStep(const QString&, int)));
+    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
+             this,                  TQT_SLOT(slotStatus(const TQString&, int)));
+    connect( controller,            TQT_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
+             this,                  TQT_SLOT(slotShowStep(const TQString&, int)));
 
     // controller -> procLineMaker
-    connect( controller,            SIGNAL(ttyStdout(const char*)),
-             procLineMaker,         SLOT(slotReceivedStdout(const char*)));
-    connect( controller,            SIGNAL(ttyStderr(const char*)),
-             procLineMaker,         SLOT(slotReceivedStderr(const char*)));
+    connect( controller,            TQT_SIGNAL(ttyStdout(const char*)),
+             procLineMaker,         TQT_SLOT(slotReceivedStdout(const char*)));
+    connect( controller,            TQT_SIGNAL(ttyStderr(const char*)),
+             procLineMaker,         TQT_SLOT(slotReceivedStderr(const char*)));
 
     // controller -> rdbOutputWidget
-    connect( controller,            SIGNAL(rdbStdout(const char*)),
-             rdbOutputWidget,       SLOT(slotReceivedStdout(const char*)) );
-    connect( controller,            SIGNAL(rdbStderr(const char*)),
-             rdbOutputWidget,       SLOT(slotReceivedStderr(const char*)) );
-    connect( controller,            SIGNAL(dbgStatus(const QString&, int)),
-             rdbOutputWidget,       SLOT(slotDbgStatus(const QString&, int)));
+    connect( controller,            TQT_SIGNAL(rdbStdout(const char*)),
+             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)));
 
 }
 
 
 bool RubyDebuggerPart::startDebugger()
 {
-    QString build_dir;              // Currently selected build directory
-    QString run_directory;          // Directory from where the program should be run
-    QString program;                // Absolute path to application
-    QString run_arguments;          // Command line arguments to be passed to the application
-    QString ruby_interpreter;       // Absolute path to the ruby interpreter
-    QString debuggee_path;          // Absolute path to debuggee.rb debugger script
+    TQString build_dir;              // Currently selected build directory
+    TQString run_directory;          // Directory from where the program should be run
+    TQString program;                // Absolute path to application
+    TQString run_arguments;          // Command line arguments to be passed to the application
+    TQString ruby_interpreter;       // Absolute path to the ruby interpreter
+    TQString debuggee_path;          // Absolute path to debuggee.rb debugger script
     bool show_constants;            // Show constants in the debugger
     bool trace_into_ruby;           // Trace into the ruby code installed under sitedir
 
@@ -465,10 +465,10 @@ bool RubyDebuggerPart::startDebugger()
 	
     run_arguments = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/programargs");
 
-    QString shell = DomUtil::readEntry(*projectDom(), "/kdevrbdebugger/general/dbgshell");
+    TQString shell = DomUtil::readEntry(*projectDom(), "/kdevrbdebugger/general/dbgshell");
     if( !shell.isEmpty() )
     {
-        QFileInfo info( shell );
+        TQFileInfo info( shell );
         if( info.isRelative() )
         {
             shell = build_dir + "/" + shell;
@@ -486,7 +486,7 @@ bool RubyDebuggerPart::startDebugger()
 
     core()->running(this, true);
 
-    stateChanged( QString("active") );
+    stateChanged( TQString("active") );
 
     KActionCollection *ac = actionCollection();
     ac->action("debug_run")->setText( i18n("&Continue") );
@@ -518,7 +518,7 @@ bool RubyDebuggerPart::startDebugger()
 	ruby_interpreter = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/interpreter");
     
 	int coding = DomUtil::readIntEntry(*projectDom(), "/kdevrubysupport/run/charactercoding");
-	QString character_coding("-K");
+	TQString character_coding("-K");
 	
 	switch (coding) {
 	case 0:
@@ -535,7 +535,7 @@ bool RubyDebuggerPart::startDebugger()
 		break;
 	}
 	
-//	ruby_interpreter.append(QString(" -K") + code);
+//	ruby_interpreter.append(TQString(" -K") + code);
 	
 	debuggee_path = ::locate("data", "kdevrbdebugger/debuggee.rb", instance());
 
@@ -577,7 +577,7 @@ void RubyDebuggerPart::slotStopDebugger()
                                            "while it is running, in order to get information "
                                            "about variables, frame stack, and so on.") );
 
-    stateChanged( QString("stopped") );
+    stateChanged( TQString("stopped") );
 
     core()->running(this, false);
 }
@@ -683,9 +683,9 @@ void RubyDebuggerPart::slotRefreshBPState( const Breakpoint& BP)
 }
 
 
-void RubyDebuggerPart::slotStatus(const QString &msg, int state)
+void RubyDebuggerPart::slotStatus(const TQString &msg, int state)
 {
-    QString stateIndicator;
+    TQString stateIndicator;
 
     if (state & s_dbgNotStarted)
     {
@@ -695,12 +695,12 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
     {
         stateIndicator = "A";
         debugger()->clearExecutionPoint();
-        stateChanged( QString("active") );
+        stateChanged( TQString("active") );
     }
     else if (state & s_programExited)
     {
         stateIndicator = "E";
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
         KActionCollection *ac = actionCollection();
         ac->action("debug_run")->setText( i18n("Restart") );
 //        ac->action("debug_run")->setIcon( "1rightarrow" );
@@ -712,7 +712,7 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
     else
     {
         stateIndicator = "P";
-        stateChanged( QString("paused") );
+        stateChanged( TQString("paused") );
     }
 
     // And now? :-)
@@ -725,7 +725,7 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
 }
 
 
-void RubyDebuggerPart::slotShowStep(const QString &fileName, int lineNum)
+void RubyDebuggerPart::slotShowStep(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
     {
@@ -735,7 +735,7 @@ void RubyDebuggerPart::slotShowStep(const QString &fileName, int lineNum)
 }
 
 
-void RubyDebuggerPart::slotGotoSource(const QString &fileName, int lineNum)
+void RubyDebuggerPart::slotGotoSource(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
         partController()->editDocument(KURL( fileName ), lineNum);
@@ -758,13 +758,13 @@ void RubyDebuggerPart::slotActivePartChanged( KParts::Part* part )
     action->setEnabled( iface != 0 );
 }
 
-void RubyDebuggerPart::restorePartialProjectSession(const QDomElement* el)
+void RubyDebuggerPart::restorePartialProjectSession(const TQDomElement* el)
 {
     rdbBreakpointWidget->restorePartialProjectSession(el);
 	variableWidget->restorePartialProjectSession(el);
 }
 
-void RubyDebuggerPart::savePartialProjectSession(QDomElement* el)
+void RubyDebuggerPart::savePartialProjectSession(TQDomElement* el)
 {
     rdbBreakpointWidget->savePartialProjectSession(el);
 	variableWidget->savePartialProjectSession(el);
diff --git a/languages/ruby/debugger/debuggerpart.h b/languages/ruby/debugger/debuggerpart.h
index 2f35df9a..637c2431 100644
--- a/languages/ruby/debugger/debuggerpart.h
+++ b/languages/ruby/debugger/debuggerpart.h
@@ -20,7 +20,7 @@
 #ifndef _DEBUGGERPART_H_
 #define _DEBUGGERPART_H_
 
-#include <qguardedptr.h>
+#include <tqguardedptr.h>
 #include "kdevplugin.h"
 #include "kdevcore.h"
 
@@ -50,14 +50,14 @@ class RubyDebuggerPart : public KDevPlugin
     Q_OBJECT
 
 public:
-    RubyDebuggerPart( QObject *parent, const char *name, const QStringList & );
+    RubyDebuggerPart( TQObject *parent, const char *name, const TQStringList & );
     ~RubyDebuggerPart();
-    virtual void restorePartialProjectSession(const QDomElement* el);
-    virtual void savePartialProjectSession(QDomElement* el);
+    virtual void restorePartialProjectSession(const TQDomElement* el);
+    virtual void savePartialProjectSession(TQDomElement* el);
 
 private slots:
     void guiClientAdded(KXMLGUIClient*);
-    void contextMenu(QPopupMenu *popup, const Context *context);
+    void contextMenu(TQPopupMenu *popup, const Context *context);
     void toggleBreakpoint();
     void contextWatch();
     void contextRubyInspect();
@@ -75,12 +75,12 @@ private slots:
     void slotStepOut();
 
     void slotRefreshBPState(const Breakpoint&);
-    void slotStatus(const QString &msg, int state);
-    void slotShowStep(const QString &fileName, int lineNum);
-    void slotGotoSource(const QString &fileName, int lineNum);
+    void slotStatus(const TQString &msg, int state);
+    void slotShowStep(const TQString &fileName, int lineNum);
+    void slotGotoSource(const TQString &fileName, int lineNum);
 
 signals:
-    void rubyInspect(const QString&);
+    void rubyInspect(const TQString&);
 
 private:
     KDevAppFrontend *appFrontend();
@@ -89,18 +89,18 @@ private:
 	bool startDebugger();
     void setupController();
 
-    QGuardedPtr<VariableWidget> variableWidget;
-    QGuardedPtr<RDBBreakpointWidget> rdbBreakpointWidget;
-    QGuardedPtr<FramestackWidget> framestackWidget;
-    QGuardedPtr<RDBOutputWidget> rdbOutputWidget;
+    TQGuardedPtr<VariableWidget> variableWidget;
+    TQGuardedPtr<RDBBreakpointWidget> rdbBreakpointWidget;
+    TQGuardedPtr<FramestackWidget> framestackWidget;
+    TQGuardedPtr<RDBOutputWidget> rdbOutputWidget;
     DbgController *controller;
-    QGuardedPtr<QLabel> statusBarIndicator;
-    QGuardedPtr<DbgToolBar> floatingToolBar;
+    TQGuardedPtr<TQLabel> statusBarIndicator;
+    TQGuardedPtr<DbgToolBar> floatingToolBar;
     ProcessLineMaker* procLineMaker;
     ProcessLineMaker* rdbLineMaker;
 
-    QString m_contextIdent;
-    QCString m_drkonqi;
+    TQString m_contextIdent;
+    TQCString m_drkonqi;
 	
     KDevDebugger *m_debugger;
 };
diff --git a/languages/ruby/debugger/framestackwidget.cpp b/languages/ruby/debugger/framestackwidget.cpp
index 836350b2..c8083dc8 100644
--- a/languages/ruby/debugger/framestackwidget.cpp
+++ b/languages/ruby/debugger/framestackwidget.cpp
@@ -25,11 +25,11 @@
 #include <klocale.h>
 #include <kdebug.h>
 
-#include <qheader.h>
-#include <qlistbox.h>
-#include <qregexp.h>
-#include <qstrlist.h>
-#include <qfileinfo.h>
+#include <tqheader.h>
+#include <tqlistbox.h>
+#include <tqregexp.h>
+#include <tqstrlist.h>
+#include <tqfileinfo.h>
 
 #include <ctype.h>
 
@@ -41,18 +41,18 @@
 namespace RDBDebugger
 {
 
-FramestackWidget::FramestackWidget(QWidget *parent, const char *name, WFlags f)
-        : QListView(parent, name, f),
+FramestackWidget::FramestackWidget(TQWidget *parent, const char *name, WFlags f)
+        : TQListView(parent, name, f),
         viewedThread_(0)
 {
     setRootIsDecorated(true);
     setSelectionMode(Single);
-    addColumn(QString());
+    addColumn(TQString());
     setSorting(0);
     header()->hide();
 
-    connect( this, SIGNAL(clicked(QListViewItem*)),
-             this, SLOT(slotSelectionChanged(QListViewItem*)) );
+    connect( this, TQT_SIGNAL(clicked(TQListViewItem*)),
+             this, TQT_SLOT(slotSelectionChanged(TQListViewItem*)) );
 }
 
 
@@ -68,12 +68,12 @@ FramestackWidget::~FramestackWidget()
 void FramestackWidget::clear()
 {
     viewedThread_ = 0;
-    QListView::clear();
+    TQListView::clear();
 }
 
 /***************************************************************************/
 
-void FramestackWidget::slotSelectionChanged(QListViewItem * item)
+void FramestackWidget::slotSelectionChanged(TQListViewItem * item)
 {
 	if (item == 0) {
 		return;
@@ -100,7 +100,7 @@ void FramestackWidget::slotSelectFrame(int frameNo, int threadNo)
 		setSelected(frame, true);
     	emit selectFrame(frameNo, threadNo, frame->frameName());
 	} else {
-    	emit selectFrame(frameNo, threadNo, QString());
+    	emit selectFrame(frameNo, threadNo, TQString());
 	}
 }
 
@@ -111,7 +111,7 @@ void FramestackWidget::parseRDBThreadList(char *str)
 	// on receipt of a thread list we must always clear the list.
     clear();
 	
-	QRegExp thread_re("(\\+)?\\s*(\\d+)\\s*(#<[^>]+>\\s*[^:]+:\\d+)");
+	TQRegExp thread_re("(\\+)?\\s*(\\d+)\\s*(#<[^>]+>\\s*[^:]+:\\d+)");
 	int pos = thread_re.search(str);
 	viewedThread_ = 0;
 	
@@ -119,7 +119,7 @@ void FramestackWidget::parseRDBThreadList(char *str)
 		ThreadStackItem* thread;
         thread = new ThreadStackItem(	this,
 										thread_re.cap(2).toInt(),
-										QString("%1 %2").arg(thread_re.cap(2)).arg(thread_re.cap(3)) );
+										TQString("%1 %2").arg(thread_re.cap(2)).arg(thread_re.cap(3)) );
 		// The thread with a '+' is always the viewedthread
         if (thread_re.cap(1) == "+") {
             viewedThread_ = thread;
@@ -148,8 +148,8 @@ void FramestackWidget::parseRDBBacktraceList(char *str)
 		}
 		
 		int frameNo = frame_re.cap(1).toInt();
-		QString frameName = QString("T%1#%2 %3").arg(viewedThread_->threadNo()).arg(frame_re.cap(1)).arg(method);
-		new FrameStackItem(viewedThread_, frameNo, QString(frame_re.cap(0)), frameName);
+		TQString frameName = TQString("T%1#%2 %3").arg(viewedThread_->threadNo()).arg(frame_re.cap(1)).arg(method);
+		new FrameStackItem(viewedThread_, frameNo, TQString(frame_re.cap(0)), frameName);
 		
 		// Tell the Variable Tree that this frame is active
 		emit frameActive(frameNo, viewedThread_->threadNo(), frameName);
@@ -169,7 +169,7 @@ void FramestackWidget::parseRDBBacktraceList(char *str)
 
 ThreadStackItem *FramestackWidget::findThread(int threadNo)
 {
-    QListViewItem *sibling = firstChild();
+    TQListViewItem *sibling = firstChild();
     while (sibling != 0) {
         ThreadStackItem *thread = (ThreadStackItem*) sibling;
         if (thread->threadNo() == threadNo) {
@@ -192,7 +192,7 @@ FrameStackItem *FramestackWidget::findFrame(int frameNo, int threadNo)
 		return 0;     // no matching thread?
 	}
 
-	QListViewItem * frameItem = thread->firstChild();
+	TQListViewItem * frameItem = thread->firstChild();
 
     while (frameItem != 0) {
         if (((FrameStackItem *) frameItem)->frameNo() == frameNo) {
@@ -211,8 +211,8 @@ FrameStackItem *FramestackWidget::findFrame(int frameNo, int threadNo)
 
 // **************************************************************************
 
-FrameStackItem::FrameStackItem(ThreadStackItem *parent, int frameNo, const QString &frameDesc, const QString& frameName)
-        : QListViewItem(parent),
+FrameStackItem::FrameStackItem(ThreadStackItem *parent, int frameNo, const TQString &frameDesc, const TQString& frameName)
+        : TQListViewItem(parent),
         frameNo_(frameNo),
         threadNo_(parent->threadNo()),
 		frameName_(frameName)		
@@ -229,7 +229,7 @@ FrameStackItem::~FrameStackItem()
 
 // **************************************************************************
 
-QString FrameStackItem::key(int /*column*/, bool /*ascending*/) const 
+TQString FrameStackItem::key(int /*column*/, bool /*ascending*/) const 
 {
 
 	return key_;
@@ -239,8 +239,8 @@ QString FrameStackItem::key(int /*column*/, bool /*ascending*/) const
 // **************************************************************************
 // **************************************************************************
 
-ThreadStackItem::ThreadStackItem(FramestackWidget *parent, int threadNo, const QString &threadDesc)
-        : QListViewItem(parent),
+ThreadStackItem::ThreadStackItem(FramestackWidget *parent, int threadNo, const TQString &threadDesc)
+        : TQListViewItem(parent),
         threadNo_(threadNo)
 {
     setText(0, threadDesc);
@@ -260,7 +260,7 @@ void ThreadStackItem::setOpen(bool open)
     if (open)
         ((FramestackWidget*)listView())->slotSelectFrame(1, threadNo());
 
-    QListViewItem::setOpen(open);
+    TQListViewItem::setOpen(open);
 }
 
 }
diff --git a/languages/ruby/debugger/framestackwidget.h b/languages/ruby/debugger/framestackwidget.h
index 373d0690..b000f042 100644
--- a/languages/ruby/debugger/framestackwidget.h
+++ b/languages/ruby/debugger/framestackwidget.h
@@ -22,8 +22,8 @@
 #ifndef _FRAMESTACKWIDGET_H_
 #define _FRAMESTACKWIDGET_H_
 
-#include <qlistview.h>
-#include <qstringlist.h>
+#include <tqlistview.h>
+#include <tqstringlist.h>
 
 #include "rdbcontroller.h"
 
@@ -36,7 +36,7 @@ class FramestackWidget;
 class ThreadStackItem : public QListViewItem
 {
 public:
-    ThreadStackItem(FramestackWidget *parent, int threadNo, const QString &threadDesc);
+    ThreadStackItem(FramestackWidget *parent, int threadNo, const TQString &threadDesc);
     virtual ~ThreadStackItem();
 
 	virtual int rtti() const { return RTTI_THREAD_STACK_ITEM; }
@@ -55,21 +55,21 @@ private:
 class FrameStackItem : public QListViewItem
 {
 public:
-    FrameStackItem(ThreadStackItem * parent, int frameNo, const QString & frameDesc, const QString & frameName);
+    FrameStackItem(ThreadStackItem * parent, int frameNo, const TQString & frameDesc, const TQString & frameName);
     virtual ~FrameStackItem();
 
 	virtual int rtti() const { return RTTI_FRAME_STACK_ITEM; }
-	virtual QString key(int column, bool ascending) const;
+	virtual TQString key(int column, bool ascending) const;
 
     int frameNo() { return frameNo_; }
     int threadNo() { return threadNo_; }
-	QString frameName() { return frameName_; }
+	TQString frameName() { return frameName_; }
 	
 private:
     int frameNo_;
     int threadNo_;
-	QString frameName_;
-	QString key_;
+	TQString frameName_;
+	TQString key_;
 };
 
 /***************************************************************************/
@@ -84,7 +84,7 @@ class FramestackWidget : public QListView
     Q_OBJECT
 
 public:
-    FramestackWidget( QWidget *parent=0, const char *name=0, WFlags f=0 );
+    FramestackWidget( TQWidget *parent=0, const char *name=0, WFlags f=0 );
     virtual ~FramestackWidget();
 
     void clear();
@@ -100,11 +100,11 @@ public:
 
 public slots:
     void slotSelectFrame(int frameNo, int threadNo);
-    void slotSelectionChanged(QListViewItem *thisItem);
+    void slotSelectionChanged(TQListViewItem *thisItem);
 
 signals:
-    void selectFrame(int frameNo, int threadNo, const QString& frameName);
-    void frameActive(int frameNo, int threadNo, const QString& frameName);
+    void selectFrame(int frameNo, int threadNo, const TQString& frameName);
+    void frameActive(int frameNo, int threadNo, const TQString& frameName);
 
 private:
     ThreadStackItem *viewedThread_;
diff --git a/languages/ruby/debugger/rdbbreakpointwidget.cpp b/languages/ruby/debugger/rdbbreakpointwidget.cpp
index e31831de..b9ead060 100644
--- a/languages/ruby/debugger/rdbbreakpointwidget.cpp
+++ b/languages/ruby/debugger/rdbbreakpointwidget.cpp
@@ -31,16 +31,16 @@
 #include <kpopupmenu.h>
 #include <kurl.h>
 
-#include <qvbuttongroup.h>
-#include <qfileinfo.h>
-#include <qheader.h>
-#include <qtable.h>
-#include <qtoolbutton.h>
-#include <qtooltip.h>
-#include <qwhatsthis.h>
-#include <qvbox.h>
-#include <qlayout.h>
-#include <qregexp.h>
+#include <tqvbuttongroup.h>
+#include <tqfileinfo.h>
+#include <tqheader.h>
+#include <tqtable.h>
+#include <tqtoolbutton.h>
+#include <tqtooltip.h>
+#include <tqwhatsthis.h>
+#include <tqvbox.h>
+#include <tqlayout.h>
+#include <tqregexp.h>
 
 #include <stdlib.h>
 #include <ctype.h>
@@ -73,7 +73,7 @@ class BreakpointTableRow : public QTableItem
 {
 public:
 
-    BreakpointTableRow(QTable* table, EditType editType, Breakpoint* bp);
+    BreakpointTableRow(TQTable* table, EditType editType, Breakpoint* bp);
     ~BreakpointTableRow();
 
     bool match (Breakpoint* bp) const;
@@ -93,9 +93,9 @@ private:
 /***************************************************************************/
 /***************************************************************************/
 
-BreakpointTableRow::BreakpointTableRow(QTable* parent, EditType editType,
+BreakpointTableRow::BreakpointTableRow(TQTable* parent, EditType editType,
                                        Breakpoint* bp) :
-        QTableItem(parent, editType, ""),
+        TQTableItem(parent, editType, ""),
         m_breakpoint(bp)
 {
     appendEmptyRow();
@@ -133,7 +133,7 @@ void BreakpointTableRow::appendEmptyRow()
 
     table()->setItem(row, Control, this);
 
-    QCheckTableItem* cti = new QCheckTableItem( table(), "");
+    TQCheckTableItem* cti = new TQCheckTableItem( table(), "");
     table()->setItem(row, Enable, cti);
 }
 
@@ -143,15 +143,15 @@ void BreakpointTableRow::setRow()
 {
     if ( m_breakpoint )
     {
-        QTableItem *item =  table()->item ( row(), Enable );
+        TQTableItem *item =  table()->item ( row(), Enable );
         Q_ASSERT(item->rtti() == 2);
-        ((QCheckTableItem*)item)->setChecked(m_breakpoint->isEnabled());
+        ((TQCheckTableItem*)item)->setChecked(m_breakpoint->isEnabled());
 
-        QString status=m_breakpoint->statusDisplay(m_activeFlag);
+        TQString status=m_breakpoint->statusDisplay(m_activeFlag);
 
         table()->setText(row(), Status, status);
 
-        QString displayType = m_breakpoint->displayType();
+        TQString displayType = m_breakpoint->displayType();
         table()->setText(row(), Location, m_breakpoint->location());
 
         if (m_breakpoint->isTemporary())
@@ -168,44 +168,44 @@ void BreakpointTableRow::setRow()
 /***************************************************************************/
 /***************************************************************************/
 
-RDBBreakpointWidget::RDBBreakpointWidget(QWidget *parent, const char *name) :
-    QHBox(parent, name)
+RDBBreakpointWidget::RDBBreakpointWidget(TQWidget *parent, const char *name) :
+    TQHBox(parent, name)
 {
-    QFrame* toolbar = new QFrame( this );
-    QVBoxLayout *l = new QVBoxLayout(toolbar, 0, 0);
+    TQFrame* toolbar = new TQFrame( this );
+    TQVBoxLayout *l = new TQVBoxLayout(toolbar, 0, 0);
 
-    toolbar->setFrameStyle( QFrame::ToolBarPanel | QFrame::Plain );
+    toolbar->setFrameStyle( TQFrame::ToolBarPanel | TQFrame::Plain );
     toolbar->setLineWidth( 0 );
 
-    m_add       = new QToolButton( toolbar, "add breakpoint" );
+    m_add       = new TQToolButton( toolbar, "add breakpoint" );
     m_add->setPixmap ( SmallIcon ( "breakpoint_add" ) );
-    QToolTip::add ( m_add, i18n ( "Add empty breakpoint" ) + I18N_NOOP(" <Alt+A>"));
-    QWhatsThis::add( m_add, i18n("<b>Add empty breakpoint</b><p>Shows a popup menu that allows you to choose "
+    TQToolTip::add ( m_add, i18n ( "Add empty breakpoint" ) + I18N_NOOP(" <Alt+A>"));
+    TQWhatsThis::add( m_add, i18n("<b>Add empty breakpoint</b><p>Shows a popup menu that allows you to choose "
         "the type of breakpoint, then adds a breakpoint of the selected type to the breakpoints list."));
 
-    m_delete    = new QToolButton( toolbar, "delete breakpoint" );
+    m_delete    = new TQToolButton( toolbar, "delete breakpoint" );
     m_delete->setPixmap ( SmallIcon ( "breakpoint_delete" ) );
-    QToolTip::add ( m_delete, i18n ( "Delete selected breakpoint" ) + I18N_NOOP(" <Delete>") );
-    QWhatsThis::add( m_delete, i18n("<b>Delete selected breakpoint</b><p>Deletes the selected breakpoint in the breakpoints list."));
+    TQToolTip::add ( m_delete, i18n ( "Delete selected breakpoint" ) + I18N_NOOP(" <Delete>") );
+    TQWhatsThis::add( m_delete, i18n("<b>Delete selected breakpoint</b><p>Deletes the selected breakpoint in the breakpoints list."));
 
-    m_edit      = new QToolButton( toolbar, "edit breakpoint" );
+    m_edit      = new TQToolButton( toolbar, "edit breakpoint" );
     m_edit->setPixmap ( SmallIcon ( "breakpoint_edit" ) );
-    QToolTip::add ( m_edit, i18n ( "Edit selected breakpoint" ) + I18N_NOOP(" <Return>")  );
-    QWhatsThis::add( m_edit, i18n("<b>Edit selected breakpoint</b><p>Allows to edit location, condition and ignore count properties of the selected breakpoint in the breakpoints list."));
+    TQToolTip::add ( m_edit, i18n ( "Edit selected breakpoint" ) + I18N_NOOP(" <Return>")  );
+    TQWhatsThis::add( m_edit, i18n("<b>Edit selected breakpoint</b><p>Allows to edit location, condition and ignore count properties of the selected breakpoint in the breakpoints list."));
 
-    m_removeAll      = new QToolButton( toolbar, "Delete all breakppoints" );
+    m_removeAll      = new TQToolButton( toolbar, "Delete all breakppoints" );
     m_removeAll->setPixmap ( SmallIcon ( "breakpoint_delete_all" ) );
-    QToolTip::add ( m_removeAll, i18n ( "Remove all breakpoints" ) );
-    QWhatsThis::add( m_removeAll, i18n("<b>Remove all breakpoints</b><p>Removes all breakpoints in the project."));
+    TQToolTip::add ( m_removeAll, i18n ( "Remove all breakpoints" ) );
+    TQWhatsThis::add( m_removeAll, i18n("<b>Remove all breakpoints</b><p>Removes all breakpoints in the project."));
 
     l->addWidget(m_add);
     l->addWidget(m_edit);
     l->addWidget(m_delete);
     l->addWidget(m_removeAll);
-    QSpacerItem* spacer = new QSpacerItem( 5, 5, QSizePolicy::Minimum, QSizePolicy::Expanding );
+    TQSpacerItem* spacer = new TQSpacerItem( 5, 5, TQSizePolicy::Minimum, TQSizePolicy::Expanding );
     l->addItem(spacer);
 
-    QPopupMenu *addMenu = new QPopupMenu( this );
+    TQPopupMenu *addMenu = new TQPopupMenu( this );
     addMenu->insertItem( i18n( "File:line" ),   BP_TYPE_FilePos );
     addMenu->insertItem( i18n( "Watchpoint" ),  BP_TYPE_Watchpoint );
     addMenu->insertItem( i18n( "Catchpoint" ),  BP_TYPE_Catchpoint );
@@ -214,17 +214,17 @@ RDBBreakpointWidget::RDBBreakpointWidget(QWidget *parent, const char *name) :
     m_add->setPopupDelay(1);
 
     m_table = new RDBTable(0, numCols, this, name);
-    m_table->setSelectionMode(QTable::SingleRow);
+    m_table->setSelectionMode(TQTable::SingleRow);
     m_table->setShowGrid (false);
     m_table->setLeftMargin(0);
-    m_table->setFocusStyle(QTable::FollowStyle);
+    m_table->setFocusStyle(TQTable::FollowStyle);
 
     m_table->hideColumn(Control);
     m_table->setColumnReadOnly(Type, true);
     m_table->setColumnReadOnly(Status, true);
     m_table->setColumnWidth( Enable, 20);
 
-    QHeader *header = m_table->horizontalHeader();
+    TQHeader *header = m_table->horizontalHeader();
 
     header->setLabel( Enable,       "" );
     header->setLabel( Type,         i18n("Type") );
@@ -233,40 +233,40 @@ RDBBreakpointWidget::RDBBreakpointWidget(QWidget *parent, const char *name) :
 
     m_table->show();
 	
-    m_ctxMenu = new QPopupMenu( this );
+    m_ctxMenu = new TQPopupMenu( this );
     m_ctxMenu->insertItem( i18n( "Show" ),    BW_ITEM_Show );
     m_ctxMenu->insertItem( i18n( "Edit" ),    BW_ITEM_Edit );
     m_ctxMenu->insertItem( i18n( "Disable" ), BW_ITEM_Disable );
     m_ctxMenu->insertItem( i18n( "Delete" ),  BW_ITEM_Delete );
 
-    connect( addMenu,     SIGNAL(activated(int)),
-             this,          SLOT(slotAddBlankBreakpoint(int)) );
-    connect( m_delete,      SIGNAL(clicked()),
-             this,          SLOT(slotRemoveBreakpoint()) );
-    connect( m_edit,        SIGNAL(clicked()),
-             this,          SLOT(slotEditBreakpoint()) );
-    connect( m_removeAll,   SIGNAL(clicked()),
-             this,          SLOT(slotRemoveAllBreakpoints()) );
+    connect( addMenu,     TQT_SIGNAL(activated(int)),
+             this,          TQT_SLOT(slotAddBlankBreakpoint(int)) );
+    connect( m_delete,      TQT_SIGNAL(clicked()),
+             this,          TQT_SLOT(slotRemoveBreakpoint()) );
+    connect( m_edit,        TQT_SIGNAL(clicked()),
+             this,          TQT_SLOT(slotEditBreakpoint()) );
+    connect( m_removeAll,   TQT_SIGNAL(clicked()),
+             this,          TQT_SLOT(slotRemoveAllBreakpoints()) );
 
-    connect( m_table,       SIGNAL(contextMenuRequested(int, int, const QPoint &)),
-             this,          SLOT(slotContextMenuShow(int, int, const QPoint & )) );
-    connect( m_ctxMenu,     SIGNAL(activated(int)),
-             this,          SLOT(slotContextMenuSelect(int)) );
+    connect( m_table,       TQT_SIGNAL(contextMenuRequested(int, int, const TQPoint &)),
+             this,          TQT_SLOT(slotContextMenuShow(int, int, const TQPoint & )) );
+    connect( m_ctxMenu,     TQT_SIGNAL(activated(int)),
+             this,          TQT_SLOT(slotContextMenuSelect(int)) );
 
-    connect( m_table,       SIGNAL(doubleClicked(int, int, int, const QPoint &)),
-             this,          SLOT(slotRowDoubleClicked(int, int, int, const QPoint &)));
+    connect( m_table,       TQT_SIGNAL(doubleClicked(int, int, int, const TQPoint &)),
+             this,          TQT_SLOT(slotRowDoubleClicked(int, int, int, const TQPoint &)));
 
-    connect( m_table,       SIGNAL(valueChanged(int, int)),
-             this,          SLOT(slotNewValue(int, int)));
+    connect( m_table,       TQT_SIGNAL(valueChanged(int, int)),
+             this,          TQT_SLOT(slotNewValue(int, int)));
 
-    connect( m_table,       SIGNAL(returnPressed()),
-             this,          SLOT(slotEditBreakpoint()));
-//    connect( m_table,       SIGNAL(f2Pressed()),
-//             this,          SLOT(slotEditBreakpoint()));
-    connect( m_table,       SIGNAL(deletePressed()),
-             this,          SLOT(slotRemoveBreakpoint()));
-    connect( m_table,       SIGNAL(insertPressed()),
-             this,          SLOT(slotAddBreakpoint()));
+    connect( m_table,       TQT_SIGNAL(returnPressed()),
+             this,          TQT_SLOT(slotEditBreakpoint()));
+//    connect( m_table,       TQT_SIGNAL(f2Pressed()),
+//             this,          TQT_SLOT(slotEditBreakpoint()));
+    connect( m_table,       TQT_SIGNAL(deletePressed()),
+             this,          TQT_SLOT(slotRemoveBreakpoint()));
+    connect( m_table,       TQT_SIGNAL(insertPressed()),
+             this,          TQT_SLOT(slotAddBreakpoint()));
 }
 
 /***************************************************************************/
@@ -362,7 +362,7 @@ BreakpointTableRow* RDBBreakpointWidget::findKey(int BPKey)
 BreakpointTableRow* RDBBreakpointWidget::addBreakpoint(Breakpoint *bp)
 {
     BreakpointTableRow* btr =
-        new BreakpointTableRow( m_table, QTableItem::WhenCurrent, bp );
+        new BreakpointTableRow( m_table, TQTableItem::WhenCurrent, bp );
     emit publishBPState(*bp);
     return btr;
 }
@@ -394,7 +394,7 @@ void RDBBreakpointWidget::removeBreakpoint(BreakpointTableRow* btr)
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotToggleBreakpoint(const QString &fileName, int lineNum)
+void RDBBreakpointWidget::slotToggleBreakpoint(const TQString &fileName, int lineNum)
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
@@ -410,7 +410,7 @@ void RDBBreakpointWidget::slotToggleBreakpoint(const QString &fileName, int line
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotToggleBreakpointEnabled(const QString &fileName, int lineNum)
+void RDBBreakpointWidget::slotToggleBreakpointEnabled(const TQString &fileName, int lineNum)
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
@@ -426,7 +426,7 @@ void RDBBreakpointWidget::slotToggleBreakpointEnabled(const QString &fileName, i
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotToggleWatchpoint(const QString &varName)
+void RDBBreakpointWidget::slotToggleWatchpoint(const TQString &varName)
 {
     Watchpoint *watchpoint = new Watchpoint(varName, false, true);
     BreakpointTableRow* btr = find(watchpoint);
@@ -482,7 +482,7 @@ void RDBBreakpointWidget::slotParseRDBBrkptList(char *str)
     // breakpoint list we can trim the breakpoints that have been
     // removed (temporary breakpoints do this)
     m_activeFlag++;
-	QRegExp breakpoint_re("(\\d+) [^:]+:\\d+");
+	TQRegExp breakpoint_re("(\\d+) [^:]+:\\d+");
 	int pos = 0;
 
 	pos = breakpoint_re.search(str, pos);
@@ -504,7 +504,7 @@ void RDBBreakpointWidget::slotParseRDBBrkptList(char *str)
 	
 	str = strstr(str, "Watchpoints:");
 	if (str != 0) {
-		QRegExp watchpoint_re("(\\d+) [^\n]+\n");
+		TQRegExp watchpoint_re("(\\d+) [^\n]+\n");
 		int pos = 0;
 	
 		pos = watchpoint_re.search(str, pos);
@@ -549,8 +549,8 @@ void RDBBreakpointWidget::slotParseRDBBreakpointSet(char *str, int BPKey)
     Breakpoint *bp = btr->breakpoint();
     bp->setDbgProcessing(false);
 
-	QRegExp breakpoint_re("Set breakpoint (\\d+) at [^:]+:\\d+");
-	QRegExp watchpoint_re("Set watchpoint (\\d+)");
+	TQRegExp breakpoint_re("Set breakpoint (\\d+) at [^:]+:\\d+");
+	TQRegExp watchpoint_re("Set watchpoint (\\d+)");
 	
 	int id = 0;
 	if (breakpoint_re.search(str, 0) != -1) {
@@ -596,7 +596,7 @@ void RDBBreakpointWidget::slotAddBlankBreakpoint(int idx)
 
     if (btr)
     {
-        QTableSelection ts;
+        TQTableSelection ts;
         ts.init(btr->row(), 0);
         ts.expandTo(btr->row(), numCols );
         m_table->addSelection(ts);
@@ -632,7 +632,7 @@ void RDBBreakpointWidget::slotRemoveAllBreakpoints()
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotRowDoubleClicked(int row, int col, int btn, const QPoint &)
+void RDBBreakpointWidget::slotRowDoubleClicked(int row, int col, int btn, const TQPoint &)
 {
     if ( btn == Qt::LeftButton )
 	{
@@ -651,7 +651,7 @@ void RDBBreakpointWidget::slotRowDoubleClicked(int row, int col, int btn, const
     }
 }
 
-void RDBBreakpointWidget::slotContextMenuShow( int row, int /*col*/, const QPoint &mousePos )
+void RDBBreakpointWidget::slotContextMenuShow( int row, int /*col*/, const TQPoint &mousePos )
 {
     BreakpointTableRow *btr = (BreakpointTableRow *)m_table->item( row, Control );
     
@@ -718,7 +718,7 @@ void RDBBreakpointWidget::slotContextMenuSelect( int item )
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotEditRow(int row, int col, const QPoint &)
+void RDBBreakpointWidget::slotEditRow(int row, int col, const TQPoint &)
 {
 //    kdDebug(9012) << "in slotEditRow row=" << row << endl;
     BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control);
@@ -745,7 +745,7 @@ void RDBBreakpointWidget::slotNewValue(int row, int col)
 
         case Enable:
         {
-            QCheckTableItem *item = (QCheckTableItem*)m_table->item ( row, Enable );
+            TQCheckTableItem *item = (TQCheckTableItem*)m_table->item ( row, Enable );
             if ( item->isChecked() != bp->isEnabled() )
             {
                 bp->setEnabled(item->isChecked());
@@ -788,7 +788,7 @@ void RDBBreakpointWidget::slotNewValue(int row, int col)
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::slotEditBreakpoint(const QString &fileName, int lineNum)
+void RDBBreakpointWidget::slotEditBreakpoint(const TQString &fileName, int lineNum)
 {
     FilePosBreakpoint *fpBP = new FilePosBreakpoint(fileName, lineNum+1);
 
@@ -797,7 +797,7 @@ void RDBBreakpointWidget::slotEditBreakpoint(const QString &fileName, int lineNu
 
     if (btr)
     {
-        QTableSelection ts;
+        TQTableSelection ts;
         ts.init(btr->row(), 0);
         ts.expandTo(btr->row(), numCols);
         m_table->addSelection(ts);
@@ -815,21 +815,21 @@ void RDBBreakpointWidget::slotEditBreakpoint()
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::savePartialProjectSession(QDomElement* el)
+void RDBBreakpointWidget::savePartialProjectSession(TQDomElement* el)
 {
-    QDomDocument domDoc = el->ownerDocument();
+    TQDomDocument domDoc = el->ownerDocument();
     if (domDoc.isNull())
         return;
 
-    QDomElement breakpointListEl = domDoc.createElement("breakpointList");
+    TQDomElement breakpointListEl = domDoc.createElement("breakpointList");
     for ( int row = 0; row < m_table->numRows(); row++ )
     {
         BreakpointTableRow* btr =
             (BreakpointTableRow *) m_table->item(row, Control);
         Breakpoint* bp = btr->breakpoint();
 
-        QDomElement breakpointEl =
-            domDoc.createElement("breakpoint"+QString::number(row));
+        TQDomElement breakpointEl =
+            domDoc.createElement("breakpoint"+TQString::number(row));
 
         breakpointEl.setAttribute("type", bp->type());
         breakpointEl.setAttribute("location", bp->location(false));
@@ -844,12 +844,12 @@ void RDBBreakpointWidget::savePartialProjectSession(QDomElement* el)
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::restorePartialProjectSession(const QDomElement* el)
+void RDBBreakpointWidget::restorePartialProjectSession(const TQDomElement* el)
 {
-    QDomElement breakpointListEl = el->namedItem("breakpointList").toElement();
+    TQDomElement breakpointListEl = el->namedItem("breakpointList").toElement();
     if (!breakpointListEl.isNull())
     {
-        QDomElement breakpointEl;
+        TQDomElement breakpointEl;
         for (breakpointEl = breakpointListEl.firstChild().toElement();
                 !breakpointEl.isNull();
                 breakpointEl = breakpointEl.nextSibling().toElement())
@@ -910,7 +910,7 @@ void RDBBreakpointWidget::slotAddBreakpoint( )
 
 /***************************************************************************/
 
-void RDBBreakpointWidget::focusInEvent( QFocusEvent */* e*/ )
+void RDBBreakpointWidget::focusInEvent( TQFocusEvent */* e*/ )
 {
     m_table->setFocus();
 }
diff --git a/languages/ruby/debugger/rdbbreakpointwidget.h b/languages/ruby/debugger/rdbbreakpointwidget.h
index 65e6e15b..22922010 100644
--- a/languages/ruby/debugger/rdbbreakpointwidget.h
+++ b/languages/ruby/debugger/rdbbreakpointwidget.h
@@ -22,8 +22,8 @@
 #ifndef _RDBBreakpointWidget_H_
 #define _RDBBreakpointWidget_H_
 
-#include <qhbox.h>
-#include <qpopupmenu.h>
+#include <tqhbox.h>
+#include <tqpopupmenu.h>
 
 class QDomElement;
 class QToolButton;
@@ -44,22 +44,22 @@ class RDBBreakpointWidget : public QHBox
     Q_OBJECT
 
 public:
-    RDBBreakpointWidget( QWidget* parent=0, const char* name=0 );
+    RDBBreakpointWidget( TQWidget* parent=0, const char* name=0 );
     virtual ~RDBBreakpointWidget();
 
     void reset();
 
-    void savePartialProjectSession(QDomElement* el);
-    void restorePartialProjectSession(const QDomElement* el);
+    void savePartialProjectSession(TQDomElement* el);
+    void restorePartialProjectSession(const TQDomElement* el);
 
 
 public slots:
     // Connected to from the editor widget:
-    void slotToggleBreakpoint(const QString &filename, int lineNum);
-    void slotToggleBreakpointEnabled(const QString &fileName, int lineNum);
+    void slotToggleBreakpoint(const TQString &filename, int lineNum);
+    void slotToggleBreakpointEnabled(const TQString &fileName, int lineNum);
 
     // Connected to from the variable widget:
-    void slotToggleWatchpoint(const QString &varName);
+    void slotToggleWatchpoint(const TQString &varName);
 
     // Connected to from the dbgcontroller:
     void slotSetPendingBPs();
@@ -71,25 +71,25 @@ public slots:
     
 protected:
     enum BW_ITEMS { BW_ITEM_Show, BW_ITEM_Edit, BW_ITEM_Disable, BW_ITEM_Delete };
-    virtual void focusInEvent(QFocusEvent *e);
+    virtual void focusInEvent(TQFocusEvent *e);
 
 private slots:
     void slotRemoveBreakpoint();
     void slotRemoveAllBreakpoints();
-    void slotEditBreakpoint(const QString &fileName, int lineNum);
+    void slotEditBreakpoint(const TQString &fileName, int lineNum);
     void slotEditBreakpoint();
     void slotAddBreakpoint();
     void slotAddBlankBreakpoint(int idx);
-    void slotRowDoubleClicked(int row, int col, int button, const QPoint & mousePos);
-    void slotContextMenuShow( int row, int col, const QPoint &mousePos );
+    void slotRowDoubleClicked(int row, int col, int button, const TQPoint & mousePos);
+    void slotContextMenuShow( int row, int col, const TQPoint &mousePos );
     void slotContextMenuSelect( int item );
-    void slotEditRow(int row, int col, const QPoint & mousePos);
+    void slotEditRow(int row, int col, const TQPoint & mousePos);
     void slotNewValue(int row, int col);
 
 signals:
     void publishBPState(const Breakpoint& brkpt);
     void refreshBPState(const Breakpoint& brkpt);
-    void gotoSourcePosition(const QString &fileName, int lineNum);
+    void gotoSourcePosition(const TQString &fileName, int lineNum);
     void clearAllBreakpoints();
 
 private:
@@ -104,11 +104,11 @@ private:
 private:
     RDBTable*       m_table;
 
-    QToolButton*    m_add;
-    QToolButton*    m_delete;
-    QToolButton*    m_edit;
-    QToolButton*    m_removeAll;
-    QPopupMenu*     m_ctxMenu;
+    TQToolButton*    m_add;
+    TQToolButton*    m_delete;
+    TQToolButton*    m_edit;
+    TQToolButton*    m_removeAll;
+    TQPopupMenu*     m_ctxMenu;
 };
 
 /***************************************************************************/
diff --git a/languages/ruby/debugger/rdbcommand.cpp b/languages/ruby/debugger/rdbcommand.cpp
index 98dc3a80..bfc630cc 100644
--- a/languages/ruby/debugger/rdbcommand.cpp
+++ b/languages/ruby/debugger/rdbcommand.cpp
@@ -27,11 +27,11 @@ namespace RDBDebugger
 {
 
 
-RDBCommand::RDBCommand(const QCString &setCommand, bool isRunCmd, bool isInfoCmd)
+RDBCommand::RDBCommand(const TQCString &setCommand, bool isRunCmd, bool isInfoCmd)
     : DbgCommand(setCommand, isRunCmd, isInfoCmd)
 {
 //    if (prompt_) {
-//        cmdBuffer_ = QCString().sprintf("set prompt %c%c\n", BLOCK_START, prompt_) +
+//        cmdBuffer_ = TQCString().sprintf("set prompt %c%c\n", BLOCK_START, prompt_) +
 //            command_ +
 //            idlePrompt_;
 //    }
@@ -48,7 +48,7 @@ RDBCommand::~RDBCommand()
 /***************************************************************************/
 
 RDBItemCommand::RDBItemCommand( VarItem *item,
-                                const QCString &command,
+                                const TQCString &command,
                                 bool isRunCmd)
     : RDBCommand(command, isRunCmd, true),
       item_(item)
@@ -62,7 +62,7 @@ RDBItemCommand::~RDBItemCommand()
 }
 
 
-RDBSetBreakpointCommand::RDBSetBreakpointCommand(const QCString &command, int key)
+RDBSetBreakpointCommand::RDBSetBreakpointCommand(const TQCString &command, int key)
     : RDBCommand(command, false, false),
       key_(key)
 {
diff --git a/languages/ruby/debugger/rdbcommand.h b/languages/ruby/debugger/rdbcommand.h
index 663c8119..0d46a5fc 100644
--- a/languages/ruby/debugger/rdbcommand.h
+++ b/languages/ruby/debugger/rdbcommand.h
@@ -51,11 +51,11 @@ enum RDBCmd
 class RDBCommand : public DbgCommand
 {
 public:
-    RDBCommand(const QCString& command, bool isRunCmd=false, bool isInfoCmd=true);
+    RDBCommand(const TQCString& command, bool isRunCmd=false, bool isInfoCmd=true);
     virtual ~RDBCommand();
 
 private:
-    static QCString idlePrompt_;
+    static TQCString idlePrompt_;
 };
 
 /***************************************************************************/
@@ -64,7 +64,7 @@ private:
 class RDBItemCommand : public RDBCommand
 {
 public:
-    RDBItemCommand(VarItem *item, const QCString &command,
+    RDBItemCommand(VarItem *item, const TQCString &command,
                    bool isRunCmd=false);
     virtual ~RDBItemCommand();
 
@@ -81,7 +81,7 @@ private:
 class RDBSetBreakpointCommand : public RDBCommand
 {
 public:
-    RDBSetBreakpointCommand(const QCString& setCommand, int key);
+    RDBSetBreakpointCommand(const TQCString& setCommand, int key);
     virtual ~RDBSetBreakpointCommand();
 
     int getKey() const        { return key_; }
diff --git a/languages/ruby/debugger/rdbcontroller.cpp b/languages/ruby/debugger/rdbcontroller.cpp
index 160754a0..f0b6ea40 100644
--- a/languages/ruby/debugger/rdbcontroller.cpp
+++ b/languages/ruby/debugger/rdbcontroller.cpp
@@ -45,11 +45,11 @@
 #include <kmessagebox.h>
 #include <kprocess.h>
 
-#include <qdatetime.h>
-#include <qfileinfo.h>
-#include <qregexp.h>
-#include <qstring.h>
-#include <qtextstream.h>
+#include <tqdatetime.h>
+#include <tqfileinfo.h>
+#include <tqregexp.h>
+#include <tqstring.h>
+#include <tqtextstream.h>
 
 #include <iostream>
 #include <ctype.h>
@@ -89,10 +89,10 @@ int debug_controllerExists = false;
 
 // At the moment a Unix domain socket is used. It might be better to
 // change to tcp/ip and listen on a port instead
-QCString RDBController::unixSocketPath_;
+TQCString RDBController::unixSocketPath_;
 
 
-RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack, QDomDocument &projectDom)
+RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack, TQDomDocument &projectDom)
         : DbgController(),
         frameStack_(frameStack),
         varTree_(varTree),
@@ -129,9 +129,9 @@ RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack
 	strcpy(sockaddr.sun_path, unixSocketPath_);
 	bind(masterSocket_, (const struct sockaddr*) &sockaddr, sizeof(sockaddr));
 	listen(masterSocket_, 1);
-	acceptNotifier_ = new QSocketNotifier(masterSocket_, QSocketNotifier::Read, this);
-    QObject::connect( acceptNotifier_, SIGNAL(activated(int)),
-                          this, SLOT(slotAcceptConnection(int)) );	
+	acceptNotifier_ = new TQSocketNotifier(masterSocket_, TQSocketNotifier::Read, this);
+    TQObject::connect( acceptNotifier_, TQT_SIGNAL(activated(int)),
+                          this, TQT_SLOT(slotAcceptConnection(int)) );	
 						  	
     configure();
     cmdList_.setAutoDelete(true);
@@ -153,7 +153,7 @@ RDBController::~RDBController()
     delete[] rdbOutput_;
     debug_controllerExists = false;
 
-	QFileInfo unixSocket(unixSocketPath_);
+	TQFileInfo unixSocket(unixSocketPath_);
 	if (unixSocket.exists()) {
 		unlink(unixSocketPath_);
 	}
@@ -231,7 +231,7 @@ void RDBController::executeCmd()
         setStateOff(s_appNotStarted|s_programExited|s_silent);
     }
 
-    QString prettyCmd = currentCmd_->cmdToSend();
+    TQString prettyCmd = currentCmd_->cmdToSend();
     prettyCmd = currentPrompt_ + prettyCmd;
     emit rdbStdout( prettyCmd.latin1() );
 	
@@ -291,7 +291,7 @@ void RDBController::pauseApp()
 
 // Whenever the program pauses we need to refresh the data visible to
 // the user. The reason we've stopped may be passed in  to be emitted.
-void RDBController::actOnProgramPause(const QString &msg)
+void RDBController::actOnProgramPause(const TQString &msg)
 {
     // We're only stopping if we were running, of course.
     if (stateIsOn(s_appBusy))
@@ -326,7 +326,7 @@ void RDBController::actOnProgramPause(const QString &msg)
 // an invalid program specified or ...
 // rdb is still running though, but only the run command (may) make sense
 // all other commands are disabled.
-void RDBController::programNoApp(const QString &msg, bool msgBox)
+void RDBController::programNoApp(const TQString &msg, bool msgBox)
 {
     state_ = (s_appNotStarted|s_programExited|(state_&(s_shuttingDown)));
     destroyCmds();
@@ -358,17 +358,17 @@ void RDBController::programNoApp(const QString &msg, bool msgBox)
 // The data gets parsed here and emitted in its component parts.
 void RDBController::parseProgramLocation(char *buf)
 {
-	QString buffer(buf);
-	QString line;
-	QTextStream input(&buffer, IO_ReadOnly);
-	QString sourceFile;
+	TQString buffer(buf);
+	TQString line;
+	TQTextStream input(&buffer, IO_ReadOnly);
+	TQString sourceFile;
 	int sourceLine = 0;
 	
     //  "1: a = 1"
-    QRegExp display_re("^(\\d+):\\s(.*)$");
+    TQRegExp display_re("^(\\d+):\\s(.*)$");
 	
     //  "/opt/qt/src/widgets/qlistview.rb:1558:puts 'hello world'"
-    QRegExp sourcepos_re("^([^:]+):(\\d+):");
+    TQRegExp sourcepos_re("^([^:]+):(\\d+):");
 		
 	line = input.readLine();
 	while (! line.isNull()) {
@@ -388,7 +388,7 @@ void RDBController::parseProgramLocation(char *buf)
 						&& !sourceFile.endsWith("/korundum.rb") ) )
 		&& !sourceFile.endsWith("/debuggee.rb") ) 
 	{
-        actOnProgramPause(QString());
+        actOnProgramPause(TQString());
         emit showStepInSource(sourceFile, sourceLine, "");
 		return;
 	}
@@ -422,7 +422,7 @@ void RDBController::parseSwitchThread(char *buf)
 {
 	// Look for the thread number
 	// 2 #<Thread:0x30091998 sleep>   /home/duke/play/testit/trykorundum/src/bar.rb:13
-    QRegExp thread_re("(\\d+)");
+    TQRegExp thread_re("(\\d+)");
 	if (thread_re.search(buf) != -1) {
 		viewedThread_ = thread_re.cap(1).toInt();
 		currentFrame_ = 1;
@@ -434,7 +434,7 @@ void RDBController::parseSwitchThread(char *buf)
 // After an 'up nnn' or 'down nnn' command, get the new source file and line no.
 void RDBController::parseFrameMove(char *buf)
 {
-	QString sourceFile;
+	TQString sourceFile;
 	int sourceLine = 0;
 	
     if (stateIsOn(s_fetchLocals)) {
@@ -442,7 +442,7 @@ void RDBController::parseFrameMove(char *buf)
 	}
 	
 	// "#2 /home/duke/play/testit/trykorundum/src/main.rb:11"
-    QRegExp sourcepos_re("#\\d+\\s([^:]+):(\\d+)");
+    TQRegExp sourcepos_re("#\\d+\\s([^:]+):(\\d+)");
 	if (sourcepos_re.search(buf) != -1) {
 		sourceFile = sourcepos_re.cap(1);
 		sourceLine = sourcepos_re.cap(2).toInt();
@@ -505,7 +505,7 @@ void RDBController::parseFrameSelected(char *buf)
 {
     if (!stateIsOn(s_silent)) {
         emit showStepInSource("", -1, "");
-        emit dbgStatus (i18n("No source: %1").arg(QString(buf)), state_);
+        emit dbgStatus (i18n("No source: %1").arg(TQString(buf)), state_);
     }
 }
 
@@ -527,7 +527,7 @@ void RDBController::parseUpdateDisplay(char *buf)
 {
 	varTree_->viewport()->setUpdatesEnabled(false);
 	
-    QRegExp display_re("(\\d+):\\s([^\n]*)\n");
+    TQRegExp display_re("(\\d+):\\s([^\n]*)\n");
 	
 	int pos = display_re.search(buf);
 	while (pos != -1) {
@@ -644,14 +644,14 @@ void RDBController::parse(char *buf)
 
 // **************************************************************************
 
-void RDBController::setBreakpoint(const QCString &BPSetCmd, int key)
+void RDBController::setBreakpoint(const TQCString &BPSetCmd, int key)
 {
     queueCmd(new RDBSetBreakpointCommand(BPSetCmd, key));
 }
 
 // **************************************************************************
 
-void RDBController::clearBreakpoint(const QCString &BPClearCmd)
+void RDBController::clearBreakpoint(const TQCString &BPClearCmd)
 {
     queueCmd(new RDBCommand(BPClearCmd, NOTRUNCMD, NOTINFOCMD));
     // Note: this is NOT an info command, because rdb doesn't explictly tell
@@ -668,7 +668,7 @@ void RDBController::modifyBreakpoint( const Breakpoint& BP )
     if (BP.dbgId() > 0)
     {
         if (BP.changedEnable())
-            queueCmd(new RDBCommand(QCString().sprintf("%s %d",
+            queueCmd(new RDBCommand(TQCString().sprintf("%s %d",
                             BP.isEnabled() ? "enable" : "disable",
                             BP.dbgId()), NOTRUNCMD, NOTINFOCMD));
 
@@ -688,7 +688,7 @@ void RDBController::modifyBreakpoint( const Breakpoint& BP )
 
 // **************************************************************************
 
-void RDBController::slotStart(const QString& ruby_interpreter, const QString& character_coding, const QString& run_directory, const QString& debuggee_path, const QString &application, const QString& run_arguments, bool show_constants, bool trace_into_ruby)
+void RDBController::slotStart(const TQString& ruby_interpreter, const TQString& character_coding, const TQString& run_directory, const TQString& debuggee_path, const TQString &application, const TQString& run_arguments, bool show_constants, bool trace_into_ruby)
 {
     Q_ASSERT (!dbgProcess_ && !tty_);
 	
@@ -696,11 +696,11 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
     tty_ = new STTY(config_dbgTerminal_, Settings::terminalEmulatorName( *kapp->config() ));
     if (!config_dbgTerminal_)
     {
-        connect( tty_, SIGNAL(OutOutput(const char*)), SIGNAL(ttyStdout(const char*)) );
-        connect( tty_, SIGNAL(ErrOutput(const char*)), SIGNAL(ttyStderr(const char*)) );
+        connect( tty_, TQT_SIGNAL(OutOutput(const char*)), TQT_SIGNAL(ttyStdout(const char*)) );
+        connect( tty_, TQT_SIGNAL(ErrOutput(const char*)), TQT_SIGNAL(ttyStderr(const char*)) );
     }
 
-    QString tty(tty_->getSlave());
+    TQString tty(tty_->getSlave());
     if (tty.isEmpty())
     {
         KMessageBox::error(0, i18n("The ruby debugger cannot use the tty* or pty* devices.\n"
@@ -716,17 +716,17 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 
     dbgProcess_ = new KProcess;
 
-    connect( dbgProcess_, SIGNAL(receivedStdout(KProcess *, char *, int)),
-             this,        SLOT(slotDbgStdout(KProcess *, char *, int)) );
+    connect( dbgProcess_, TQT_SIGNAL(receivedStdout(KProcess *, char *, int)),
+             this,        TQT_SLOT(slotDbgStdout(KProcess *, char *, int)) );
 
-    connect( dbgProcess_, SIGNAL(receivedStderr(KProcess *, char *, int)),
-             this,        SLOT(slotDbgStderr(KProcess *, char *, int)) );
+    connect( dbgProcess_, TQT_SIGNAL(receivedStderr(KProcess *, char *, int)),
+             this,        TQT_SLOT(slotDbgStderr(KProcess *, char *, int)) );
 
-    connect( dbgProcess_, SIGNAL(wroteStdin(KProcess *)),
-             this,        SLOT(slotDbgWroteStdin(KProcess *)) );
+    connect( dbgProcess_, TQT_SIGNAL(wroteStdin(KProcess *)),
+             this,        TQT_SLOT(slotDbgWroteStdin(KProcess *)) );
 
-    connect( dbgProcess_, SIGNAL(processExited(KProcess*)),
-             this,        SLOT(slotDbgProcessExited(KProcess*)) );
+    connect( dbgProcess_, TQT_SIGNAL(processExited(KProcess*)),
+             this,        TQT_SLOT(slotDbgProcessExited(KProcess*)) );
 
 	rubyInterpreter_ = ruby_interpreter;
 	characterCoding_ = character_coding;
@@ -739,7 +739,7 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 
 	*dbgProcess_ << ruby_interpreter;
 	*dbgProcess_ << character_coding;
-	*dbgProcess_ << "-C" << QString(QFile::encodeName( run_directory ));
+	*dbgProcess_ << "-C" << TQString(TQFile::encodeName( run_directory ));
 	*dbgProcess_ << "-r" << debuggee_path;
 	*dbgProcess_ << application;
 	
@@ -747,8 +747,8 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 		*dbgProcess_ << run_arguments;
 	}
 
-    emit rdbStdout(QString( ruby_interpreter + " " + character_coding
-							+ " -C " + QString(QFile::encodeName( run_directory ))
+    emit rdbStdout(TQString( ruby_interpreter + " " + character_coding
+							+ " -C " + TQString(TQFile::encodeName( run_directory ))
 							+ " -r " + debuggee_path + " " 
 							+ application + " " + run_arguments ).latin1() );
 
@@ -766,9 +766,9 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
     // BUT the app hasn't been started yet! A run command is about to be issued
     // by whoever is controlling us.
 	
-    if (!dbgProcess_->writeStdin(QString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
+    if (!dbgProcess_->writeStdin(TQString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
         kdDebug(9012) << "failed to write Unix domain socket path to rdb " 
-		<< QString("%1\n").arg(unixSocketPath_).latin1() << endl;
+		<< TQString("%1\n").arg(unixSocketPath_).latin1() << endl;
 	}
 	
 	setStateOff(s_programExited);
@@ -785,8 +785,8 @@ void RDBController::slotStopDebugger()
     setStateOn(s_shuttingDown|s_silent);
     destroyCmds();
 
-    QTime start;
-    QTime now;
+    TQTime start;
+    TQTime now;
 
     // Get rdb's attention if it's busy. We need rdb to be at the
     // command line so we can stop it.
@@ -794,11 +794,11 @@ void RDBController::slotStopDebugger()
     {
         kdDebug(9012) << "ruby debugger busy on shutdown - stopping rdb (SIGINT)" << endl;
         dbgProcess_->kill(SIGINT);
-        start = QTime::currentTime();
+        start = TQTime::currentTime();
         while (-1)
         {
             kapp->processEvents(20);
-            now = QTime::currentTime();
+            now = TQTime::currentTime();
             if (!stateIsOn(s_appBusy) || start.msecsTo( now ) > 2000)
                 break;
         }
@@ -813,11 +813,11 @@ void RDBController::slotStopDebugger()
         kdDebug(9012) << "failed to write 'quit' to ruby debugger" << endl;
 
     emit rdbStdout("(rdb:1) quit");
-    start = QTime::currentTime();
+    start = TQTime::currentTime();
     while (-1)
     {
          kapp->processEvents(20);
-         now = QTime::currentTime();
+         now = TQTime::currentTime();
          if (stateIsOn(s_programExited) || start.msecsTo( now ) > 2000)
              break;
     }
@@ -858,17 +858,17 @@ void RDBController::slotRun()
 
 // **************************************************************************
 
-void RDBController::slotRunUntil(const QString &fileName, int lineNum)
+void RDBController::slotRunUntil(const TQString &fileName, int lineNum)
 {
     if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (fileName.isEmpty())
-        queueCmd(new RDBCommand( QCString().sprintf("break %d", lineNum),
+        queueCmd(new RDBCommand( TQCString().sprintf("break %d", lineNum),
                                 RUNCMD, NOTINFOCMD));
     else
         queueCmd(new RDBCommand(
-                QCString().sprintf("break %s:%d", fileName.latin1(), lineNum),
+                TQCString().sprintf("break %s:%d", fileName.latin1(), lineNum),
                                 RUNCMD, NOTINFOCMD));
     queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
 								
@@ -1014,7 +1014,7 @@ void RDBController::slotClearAllBreakpoints()
 
 // **************************************************************************
 
-void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& frameName)
+void RDBController::slotSelectFrame(int frameNo, int threadNo, const TQString& frameName)
 {
 	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown)) {
 		kdDebug(9012) << "RDBController::slotSelectFrame wrong state" << endl;
@@ -1023,19 +1023,19 @@ void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& fr
 
 	if (viewedThread_ != threadNo) {
 		// Note that 'thread switch nnn' is a run command
-		queueCmd(new RDBCommand(QCString().sprintf("thread switch %d",
+		queueCmd(new RDBCommand(TQCString().sprintf("thread switch %d",
                                 threadNo), RUNCMD, INFOCMD));
 		executeCmd();
 		return;
 	}
 		
 	if (frameNo > currentFrame_) {
-    	queueCmd(new RDBCommand(QCString().sprintf("up %d", frameNo - currentFrame_), NOTRUNCMD, INFOCMD));
+    	queueCmd(new RDBCommand(TQCString().sprintf("up %d", frameNo - currentFrame_), NOTRUNCMD, INFOCMD));
 		if (!stateIsOn(s_fetchLocals)) {
         	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
 		}
 	} else if (frameNo < currentFrame_) {
-    	queueCmd(new RDBCommand(QCString().sprintf("down %d", currentFrame_ - frameNo), NOTRUNCMD, INFOCMD));
+    	queueCmd(new RDBCommand(TQCString().sprintf("down %d", currentFrame_ - frameNo), NOTRUNCMD, INFOCMD));
 		if (!stateIsOn(s_fetchLocals)) {
         	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
 		}
@@ -1080,7 +1080,7 @@ void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& fr
 // **************************************************************************
 
 // This is called when an item needs special processing to show a value.
-void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
+void RDBController::slotExpandItem(VarItem *item, const TQCString &userRequest)
 {
 	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
         return;
@@ -1091,7 +1091,7 @@ void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
     if (userRequest.isEmpty())
         return;
 
-    queueCmd(new RDBItemCommand(item, QCString("pp ") + userRequest.data(), false));
+    queueCmd(new RDBItemCommand(item, TQCString("pp ") + userRequest.data(), false));
 	
 	if (currentCmd_ == 0) {
 		executeCmd();
@@ -1101,9 +1101,9 @@ void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
 // **************************************************************************
 
 // This method evaluates text selected with the 'Inspect:' context menu
-void RDBController::slotRubyInspect(const QString &inspectText)
+void RDBController::slotRubyInspect(const TQString &inspectText)
 {
-    queueCmd(new RDBCommand(	QCString().sprintf("p %s", inspectText.latin1()), 
+    queueCmd(new RDBCommand(	TQCString().sprintf("p %s", inspectText.latin1()), 
 								NOTRUNCMD, 
 								INFOCMD ), true );
 	executeCmd();
@@ -1113,9 +1113,9 @@ void RDBController::slotRubyInspect(const QString &inspectText)
 // **************************************************************************
 
 // Add a new expression to be displayed in the Watch variable tree
-void RDBController::slotAddWatchExpression(const QString& expr, bool execute)
+void RDBController::slotAddWatchExpression(const TQString& expr, bool execute)
 {
-	queueCmd(new RDBCommand(	QCString().sprintf("display %s", expr.latin1()), 
+	queueCmd(new RDBCommand(	TQCString().sprintf("display %s", expr.latin1()), 
 								NOTRUNCMD, 
 								NOTINFOCMD ) );
 	if (execute) {
@@ -1128,7 +1128,7 @@ void RDBController::slotAddWatchExpression(const QString& expr, bool execute)
 // Add a new expression to be displayed in the Watch variable tree
 void RDBController::slotRemoveWatchExpression(int displayId)
 {
-    queueCmd(new RDBCommand(	QCString().sprintf("undisplay %d", displayId), 
+    queueCmd(new RDBCommand(	TQCString().sprintf("undisplay %d", displayId), 
 								NOTRUNCMD, 
 								INFOCMD ) );
 	executeCmd();
@@ -1156,7 +1156,7 @@ void RDBController::slotFetchGlobals(bool fetch)
 // Data from the ruby program's stdout gets processed here.
 void RDBController::slotDbgStdout(KProcess *, char *buf, int buflen)
 {
-    QCString msg(buf, buflen+1);
+    TQCString msg(buf, buflen+1);
     emit ttyStdout(msg);
 }
 
@@ -1165,7 +1165,7 @@ void RDBController::slotDbgStdout(KProcess *, char *buf, int buflen)
 // Data from the ruby program's stderr gets processed here.
 void RDBController::slotDbgStderr(KProcess *, char *buf, int buflen)
 {
-    QCString msg(buf, buflen+1);
+    TQCString msg(buf, buflen+1);
     emit ttyStderr(msg);
 }
 
@@ -1198,9 +1198,9 @@ void RDBController::slotAcceptConnection(int masterSocket)
     	kdDebug(9012) << "RDBController::slotAcceptConnection can't set nonblocking socket " << errno << endl;
 	}
 	
-	socketNotifier_ = new QSocketNotifier(socket_, QSocketNotifier::Read, 0);
-    QObject::connect( socketNotifier_, SIGNAL(activated(int)),
-                          this, SLOT(slotReadFromSocket(int)) );	
+	socketNotifier_ = new TQSocketNotifier(socket_, TQSocketNotifier::Read, 0);
+    TQObject::connect( socketNotifier_, TQT_SIGNAL(activated(int)),
+                          this, TQT_SLOT(slotReadFromSocket(int)) );	
     
 	setStateOff(s_dbgNotStarted);
     emit dbgStatus ("", state_);
@@ -1245,7 +1245,7 @@ void RDBController::slotReadFromSocket(int socket)
 
 //    kdDebug(9012) << "RDBController::slotReadFromSocket length: " << rdbOutputLen_ << " input: " << rdbOutput_ << endl;
 	
-	QRegExp prompt_re("(\\(rdb:(\\d+)\\) )$");
+	TQRegExp prompt_re("(\\(rdb:(\\d+)\\) )$");
  	int promptPos = prompt_re.search(rdbOutput_, 0);
 	
 	// Keep appending output to the rbdOutput_ buffer until the
@@ -1303,54 +1303,54 @@ void RDBController::slotDbgProcessExited(KProcess*)
 
 // Takes abbreviated commands and expands them, before passing them on to rdb
 //
-void RDBController::slotUserRDBCmd(const QString& cmd)
+void RDBController::slotUserRDBCmd(const TQString& cmd)
 {
     kdDebug(9012) << "Requested user cmd: " << cmd << endl;
-    QRegExp break_re("^b(reak)?(\\s.*)?");
-    QRegExp watch_re("^wat(ch)?\\s+(.*)");
-    QRegExp delete_re("^del(ete)?(\\s.*)?");
-    QRegExp display_re("^disp(lay)?(\\s.*)?");
-    QRegExp undisplay_re("^undisp(lay)?(\\s.*)?");
-    QRegExp step_re("^s(tep)?(\\s[\\d]+)?$");
-    QRegExp next_re("^n(ext)?(\\s[\\d]+)?$");
-    QRegExp varlocal_re("^v(ar)?\\s+l(ocal)?");
-    QRegExp varglobal_re("^v(ar)?\\s+g(lobal)?");
-    QRegExp varinstance_re("^v(ar)?\\s+i(nstance)?\\s(.*)");
-    QRegExp varconst_re("^v(ar)?\\s+c(onst)?\\s(.*)");
-    QRegExp threadlist_re("^th(read)?\\s+l(ist)?");
-    QRegExp threadcurrent_re("^th(read)?(\\sc(ur(rent)?)?)?$");
-    QRegExp threadswitch_re("^th(read)?(\\ssw(itch)?)?(\\s.*)");
-    QRegExp thread_re("^th(read)?(\\s+.*)?");
-    QRegExp methodinstance_re("^m(ethod)?\\s+i(nstance)?\\s+(.*)");
-    QRegExp method_re("^m(ethod)?\\s+(.*)");
-    QRegExp list_re("^l(ist)?(\\s+\\d+-\\d+)?$");
+    TQRegExp break_re("^b(reak)?(\\s.*)?");
+    TQRegExp watch_re("^wat(ch)?\\s+(.*)");
+    TQRegExp delete_re("^del(ete)?(\\s.*)?");
+    TQRegExp display_re("^disp(lay)?(\\s.*)?");
+    TQRegExp undisplay_re("^undisp(lay)?(\\s.*)?");
+    TQRegExp step_re("^s(tep)?(\\s[\\d]+)?$");
+    TQRegExp next_re("^n(ext)?(\\s[\\d]+)?$");
+    TQRegExp varlocal_re("^v(ar)?\\s+l(ocal)?");
+    TQRegExp varglobal_re("^v(ar)?\\s+g(lobal)?");
+    TQRegExp varinstance_re("^v(ar)?\\s+i(nstance)?\\s(.*)");
+    TQRegExp varconst_re("^v(ar)?\\s+c(onst)?\\s(.*)");
+    TQRegExp threadlist_re("^th(read)?\\s+l(ist)?");
+    TQRegExp threadcurrent_re("^th(read)?(\\sc(ur(rent)?)?)?$");
+    TQRegExp threadswitch_re("^th(read)?(\\ssw(itch)?)?(\\s.*)");
+    TQRegExp thread_re("^th(read)?(\\s+.*)?");
+    TQRegExp methodinstance_re("^m(ethod)?\\s+i(nstance)?\\s+(.*)");
+    TQRegExp method_re("^m(ethod)?\\s+(.*)");
+    TQRegExp list_re("^l(ist)?(\\s+\\d+-\\d+)?$");
     
     if ( break_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("break%s", break_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("break%s", break_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( watch_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("watch %s", watch_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("watch %s", watch_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( delete_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("delete%s", delete_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("delete%s", delete_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( display_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("display%s", display_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("display%s", display_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( undisplay_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("undisplay%s", undisplay_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("undisplay%s", undisplay_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( step_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("step%s", step_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("step%s", step_re.cap(2).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( next_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("next%s", next_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("next%s", next_re.cap(2).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( varlocal_re.search(cmd) >= 0 ) {
@@ -1358,23 +1358,23 @@ void RDBController::slotUserRDBCmd(const QString& cmd)
     } else if ( varglobal_re.search(cmd) >= 0 ) {
         queueCmd(new RDBCommand("var global", NOTRUNCMD, INFOCMD));
     } else if ( varinstance_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("var instance %s", varinstance_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("var instance %s", varinstance_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( varconst_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("var const %s", varconst_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("var const %s", varconst_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( methodinstance_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("method instance %s", methodinstance_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("method instance %s", methodinstance_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( method_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("method %s", method_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("method %s", method_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( list_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("list%s", list_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("list%s", list_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
 	} else if (cmd == "c" || cmd == "cont") {
@@ -1386,11 +1386,11 @@ void RDBController::slotUserRDBCmd(const QString& cmd)
     } else if ( threadcurrent_re.search(cmd) >= 0 ) {
         queueCmd(new RDBCommand("thread current", NOTRUNCMD, INFOCMD), true );
     } else if ( threadswitch_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("thread switch%s", threadswitch_re.cap(4).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("thread switch%s", threadswitch_re.cap(4).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( thread_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("thread%s", thread_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("thread%s", thread_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if (cmd == "frame" || cmd == "f" || cmd == "where" || cmd == "w") {
diff --git a/languages/ruby/debugger/rdbcontroller.h b/languages/ruby/debugger/rdbcontroller.h
index 2d303218..e2ed0746 100644
--- a/languages/ruby/debugger/rdbcontroller.h
+++ b/languages/ruby/debugger/rdbcontroller.h
@@ -29,12 +29,12 @@
 
 #include "dbgcontroller.h"
 
-#include <qcstring.h>
-#include <qdom.h>
-#include <qobject.h>
-#include <qptrlist.h>
-#include <qstring.h>
-#include <qsocketnotifier.h> 
+#include <tqcstring.h>
+#include <tqdom.h>
+#include <tqobject.h>
+#include <tqptrlist.h>
+#include <tqstring.h>
+#include <tqsocketnotifier.h> 
 
 class KProcess;
 
@@ -58,7 +58,7 @@ class RDBController : public DbgController
     Q_OBJECT
 
 public:
-    RDBController(VariableTree *varTree, FramestackWidget *frameStack, QDomDocument &projectDom);
+    RDBController(VariableTree *varTree, FramestackWidget *frameStack, TQDomDocument &projectDom);
     ~RDBController();
 
 protected:
@@ -84,11 +84,11 @@ private:
     void executeCmd ();
     void destroyCmds();
     void removeInfoRequests();
-    void actOnProgramPause(const QString &msg);
-    void programNoApp(const QString &msg, bool msgBox);
+    void actOnProgramPause(const TQString &msg);
+    void programNoApp(const TQString &msg, bool msgBox);
 
-    void setBreakpoint(const QCString &BPSetCmd, int key);
-    void clearBreakpoint(const QCString &BPClearCmd);
+    void setBreakpoint(const TQCString &BPSetCmd, int key);
+    void clearBreakpoint(const TQCString &BPClearCmd);
     void modifyBreakpoint(const Breakpoint&);
 
     void setStateOn(int stateOn)    { state_ |= stateOn; }
@@ -98,16 +98,16 @@ private:
 public slots:
     void configure();
 
-    void slotStart(	const QString& shell, const QString& characterCoding, 
-					const QString& run_directory, const QString& debuggee_path, 
-					const QString &application, const QString& run_arguments,
+    void slotStart(	const TQString& shell, const TQString& characterCoding, 
+					const TQString& run_directory, const TQString& debuggee_path, 
+					const TQString &application, const TQString& run_arguments,
                     bool show_constants, bool trace_into_ruby );
-    //void slotStart(const QString& shell, const QString &application);
+    //void slotStart(const TQString& shell, const TQString &application);
 
     void slotStopDebugger();
 
     void slotRun();
-    void slotRunUntil(const QString &filename, int lineNum);
+    void slotRunUntil(const TQString &filename, int lineNum);
     void slotStepInto();
     void slotStepOver();
     void slotStepOutOff();
@@ -116,14 +116,14 @@ public slots:
     void slotBPState( const Breakpoint& );
     void slotClearAllBreakpoints();
 
-    void slotExpandItem(VarItem *parent, const QCString &userRequest);
-    void slotRubyInspect(const QString &inspectText);
-    void slotSelectFrame(int frameNo, int threadNo, const QString& frameName);
+    void slotExpandItem(VarItem *parent, const TQCString &userRequest);
+    void slotRubyInspect(const TQString &inspectText);
+    void slotSelectFrame(int frameNo, int threadNo, const TQString& frameName);
     void slotFetchGlobals(bool fetch);
-    void slotAddWatchExpression(const QString& expr, bool execute);
+    void slotAddWatchExpression(const TQString& expr, bool execute);
 	void slotRemoveWatchExpression(int displayId);
 
-    void slotUserRDBCmd(const QString&);
+    void slotUserRDBCmd(const TQString&);
 
 protected slots:
     void slotDbgStdout(KProcess *proc, char *buf, int buflen);
@@ -137,7 +137,7 @@ protected slots:
 signals:
     void acceptPendingBPs     ();
     void unableToSetBPNow     (int BPNo);
-    void addWatchExpression     (const QString&);
+    void addWatchExpression     (const TQString&);
 
 private:
     FramestackWidget* frameStack_;
@@ -149,31 +149,31 @@ private:
 	                                         // from the ruby program
     int               stdoutOutputLen_;      // amount of data in the output buffer
     char*             stdoutOutput_;         // buffer for the output from kprocess
-    QCString          holdingZone_;
+    TQCString          holdingZone_;
     
 	int               rdbSizeofBuf_;         // size of the output buffer from rdb
     int               rdbOutputLen_;         // amount of data in the rdb buffer
     char*             rdbOutput_;            // buffer for the output from rdb via the Unix socket
 	
 	int               masterSocket_;         // The socket to accept connections
-	QSocketNotifier*  acceptNotifier_;
-    static QCString   unixSocketPath_;       // The name of the Unix Domain socket
+	TQSocketNotifier*  acceptNotifier_;
+    static TQCString   unixSocketPath_;       // The name of the Unix Domain socket
 	int               socket_;               // The socket to read and write to the debuggee
-	QSocketNotifier*  socketNotifier_;
+	TQSocketNotifier*  socketNotifier_;
 
-    QPtrList<DbgCommand> cmdList_;
+    TQPtrList<DbgCommand> cmdList_;
     DbgCommand*       currentCmd_;
-	QString           currentPrompt_;
+	TQString           currentPrompt_;
 
     STTY*             tty_;
 	
 	// Details for starting the ruby debugger process
-	QString          rubyInterpreter_;
-	QString          characterCoding_;
-	QString          runDirectory_;
-	QString          debuggeePath_;
-	QString          application_;
-	QString          runArguments_;
+	TQString          rubyInterpreter_;
+	TQString          characterCoding_;
+	TQString          runDirectory_;
+	TQString          debuggeePath_;
+	TQString          application_;
+	TQString          runArguments_;
     bool             showConstants_;
     bool             traceIntoRuby_;
 
@@ -182,7 +182,7 @@ private:
     bool              programHasExited_;
 
     // Configuration values
-    QDomDocument &dom;
+    TQDomDocument &dom;
     bool    config_forceBPSet_;
     bool    config_dbgTerminal_;
 };
diff --git a/languages/ruby/debugger/rdboutputwidget.cpp b/languages/ruby/debugger/rdboutputwidget.cpp
index 5e08e116..6eef01c7 100644
--- a/languages/ruby/debugger/rdboutputwidget.cpp
+++ b/languages/ruby/debugger/rdboutputwidget.cpp
@@ -29,11 +29,11 @@
 #include <kiconloader.h>
 #include <klocale.h>
 
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qtextedit.h>
-#include <qtoolbutton.h>
-#include <qtooltip.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqtextedit.h>
+#include <tqtoolbutton.h>
+#include <tqtooltip.h>
 
 /***************************************************************************/
 /***************************************************************************/
@@ -44,45 +44,45 @@ namespace RDBDebugger
 
 /***************************************************************************/
 
-RDBOutputWidget::RDBOutputWidget( QWidget *parent, const char *name) :
-    QWidget(parent, name),
+RDBOutputWidget::RDBOutputWidget( TQWidget *parent, const char *name) :
+    TQWidget(parent, name),
     m_userRDBCmdEditor(0),
     m_Interrupt(0),
     m_rdbView(0)
 {
 
-    m_rdbView = new QTextEdit (this, name);
+    m_rdbView = new TQTextEdit (this, name);
     m_rdbView->setReadOnly(true);
 
-    QBoxLayout *userRDBCmdEntry = new QHBoxLayout();
+    TQBoxLayout *userRDBCmdEntry = new TQHBoxLayout();
     m_userRDBCmdEditor = new KHistoryCombo (this, "rdb-user-cmd-editor");
 
-    QLabel *label = new QLabel(i18n("&RDB cmd:"), this);
+    TQLabel *label = new TQLabel(i18n("&RDB cmd:"), this);
     label->setBuddy(m_userRDBCmdEditor);
     userRDBCmdEntry->addWidget(label);
 
     userRDBCmdEntry->addWidget(m_userRDBCmdEditor);
     userRDBCmdEntry->setStretchFactor(m_userRDBCmdEditor, 1);
 
-    m_Interrupt = new QToolButton( this, "add breakpoint" );
-    m_Interrupt->setSizePolicy ( QSizePolicy ( (QSizePolicy::SizeType)0,
-                                         ( QSizePolicy::SizeType)0,
+    m_Interrupt = new TQToolButton( this, "add breakpoint" );
+    m_Interrupt->setSizePolicy ( TQSizePolicy ( (TQSizePolicy::SizeType)0,
+                                         ( TQSizePolicy::SizeType)0,
                                          0,
                                          0,
                                          m_Interrupt->sizePolicy().hasHeightForWidth())
                                          );
     m_Interrupt->setPixmap ( SmallIcon ( "player_pause" ) );
     userRDBCmdEntry->addWidget(m_Interrupt);
-    QToolTip::add ( m_Interrupt, i18n ( "Pause execution of the app to enter rdb commands" ) );
+    TQToolTip::add ( m_Interrupt, i18n ( "Pause execution of the app to enter rdb commands" ) );
 
-    QVBoxLayout *topLayout = new QVBoxLayout(this, 2);
+    TQVBoxLayout *topLayout = new TQVBoxLayout(this, 2);
     topLayout->addWidget(m_rdbView, 10);
     topLayout->addLayout(userRDBCmdEntry);
 
     slotDbgStatus( "", s_dbgNotStarted);
 
-    connect( m_userRDBCmdEditor, SIGNAL(returnPressed()), SLOT(slotRDBCmd()) );
-    connect( m_Interrupt,        SIGNAL(clicked()),       SIGNAL(breakInto()));
+    connect( m_userRDBCmdEditor, TQT_SIGNAL(returnPressed()), TQT_SLOT(slotRDBCmd()) );
+    connect( m_Interrupt,        TQT_SIGNAL(clicked()),       TQT_SIGNAL(breakInto()));
 }
 
 /***************************************************************************/
@@ -106,7 +106,7 @@ void RDBOutputWidget::clear()
 void RDBOutputWidget::slotReceivedStdout(const char* line)
 {
     if (strncmp(line, "(rdb:", 5) == 0)
-        m_rdbView->append(QString("<font color=\"blue\">").append( line ).append("</font>") );
+        m_rdbView->append(TQString("<font color=\"blue\">").append( line ).append("</font>") );
     else
         m_rdbView->append(line);
 }
@@ -115,14 +115,14 @@ void RDBOutputWidget::slotReceivedStdout(const char* line)
 
 void RDBOutputWidget::slotReceivedStderr(const char* line)
 {
-    m_rdbView->append(QString("<font color=\"red\">").append( line ).append("</font>") );
+    m_rdbView->append(TQString("<font color=\"red\">").append( line ).append("</font>") );
 }
 
 /***************************************************************************/
 
 void RDBOutputWidget::slotRDBCmd()
 {
-    QString RDBCmd(m_userRDBCmdEditor->currentText());
+    TQString RDBCmd(m_userRDBCmdEditor->currentText());
     if (!RDBCmd.isEmpty())
     {
         m_userRDBCmdEditor->addToHistory(RDBCmd);
@@ -133,7 +133,7 @@ void RDBOutputWidget::slotRDBCmd()
 
 /***************************************************************************/
 
-void RDBOutputWidget::slotDbgStatus(const QString &, int statusFlag)
+void RDBOutputWidget::slotDbgStatus(const TQString &, int statusFlag)
 {
     if (statusFlag & s_dbgNotStarted)
     {
@@ -156,7 +156,7 @@ void RDBOutputWidget::slotDbgStatus(const QString &, int statusFlag)
 
 /***************************************************************************/
 
-void RDBOutputWidget::focusInEvent(QFocusEvent */*e*/)
+void RDBOutputWidget::focusInEvent(TQFocusEvent */*e*/)
 {
     m_userRDBCmdEditor->setFocus();
 }
diff --git a/languages/ruby/debugger/rdboutputwidget.h b/languages/ruby/debugger/rdboutputwidget.h
index ef466757..051c65bb 100644
--- a/languages/ruby/debugger/rdboutputwidget.h
+++ b/languages/ruby/debugger/rdboutputwidget.h
@@ -24,7 +24,7 @@
 #ifndef _RDBOUTPUTWIDGET_H_
 #define _RDBOUTPUTWIDGET_H_
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 class KHistoryCombo;
 
@@ -39,7 +39,7 @@ class RDBOutputWidget : public QWidget
     Q_OBJECT
 
 public:
-    RDBOutputWidget( QWidget *parent=0, const char *name=0 );
+    RDBOutputWidget( TQWidget *parent=0, const char *name=0 );
     ~RDBOutputWidget();
 
     void clear();
@@ -47,21 +47,21 @@ public:
 public slots:
     void slotReceivedStdout(const char* line);
     void slotReceivedStderr(const char* line);
-    void slotDbgStatus     (const QString &status, int statusFlag);
+    void slotDbgStatus     (const TQString &status, int statusFlag);
 
     void slotRDBCmd();
 
 protected:
-    virtual void focusInEvent(QFocusEvent *e);
+    virtual void focusInEvent(TQFocusEvent *e);
 
 signals:
-    void userRDBCmd(const QString &cmd);
+    void userRDBCmd(const TQString &cmd);
     void breakInto();
 
 private:
     KHistoryCombo*  m_userRDBCmdEditor;
-    QToolButton*    m_Interrupt;
-    QTextEdit*      m_rdbView;
+    TQToolButton*    m_Interrupt;
+    TQTextEdit*      m_rdbView;
 };
 
 }
diff --git a/languages/ruby/debugger/rdbparser.cpp b/languages/ruby/debugger/rdbparser.cpp
index 7792acc5..c1cd7717 100644
--- a/languages/ruby/debugger/rdbparser.cpp
+++ b/languages/ruby/debugger/rdbparser.cpp
@@ -22,7 +22,7 @@
 #include "rdbparser.h"
 #include "variablewidget.h"
 
-#include <qregexp.h>
+#include <tqregexp.h>
 
 #include <ctype.h>
 #include <stdlib.h>
@@ -51,9 +51,9 @@ void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
         buf = (char*)unknown;
 	}
 		
-	QRegExp var_re("\\s*([^\\n\\s]+) => ([^\\n]+)");
-	QRegExp ref_re("(#<([^:]|::)+:0x[\\da-f]+)\\s*([^=]*)>?");
-	QRegExp struct_re("#<struct Struct::(\\w+)");
+	TQRegExp var_re("\\s*([^\\n\\s]+) => ([^\\n]+)");
+	TQRegExp ref_re("(#<([^:]|::)+:0x[\\da-f]+)\\s*([^=]*)>?");
+	TQRegExp struct_re("#<struct Struct::(\\w+)");
 	
 	// Look for 'dataitem => value' pairs. For example:
 	// 	a => 1
@@ -71,7 +71,7 @@ void RDBParser::parseVariables(LazyFetchItem *parent, char *buf)
 					value = var_re.cap(2).latin1();
 				}
 			} else if (struct_re.search(var_re.cap(2)) != -1) {
-				value = (QString("#<Struct::") + struct_re.cap(1) + ">").latin1();
+				value = (TQString("#<Struct::") + struct_re.cap(1) + ">").latin1();
 			} else {
 				value = var_re.cap(2).latin1();
 			}
@@ -100,7 +100,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 	int			pos;
 	QString		varName;
 	QCString	value;
-	QRegExp 	ppref_re("(#<([^:]|::)+:0x[\\da-f]+)([^\\n>]*)(>?)");
+	TQRegExp 	ppref_re("(#<([^:]|::)+:0x[\\da-f]+)([^\\n>]*)(>?)");
     
 	switch (parent->dataType()) {
     case REFERENCE_TYPE:
@@ -112,14 +112,14 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 		//		@sleeper=#<Thread:0x3008fd18 sleep>,
 		//		@temp={"z"=>"zed", "p"=>"pee"}>
 		//
-		QRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]");
+		TQRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]");
 
 		pos = ppref_re.search(buf);
 		if (pos != -1) {
 			if (ppref_re.cap(4) != "") {
 				// The value is all on one line, so match against name=value 
 				// pairs which can't have commas in their values
-				ppvalue_re = QRegExp("\\s*([^\\s=]+)=([^,>]+)([,>])");
+				ppvalue_re = TQRegExp("\\s*([^\\s=]+)=([^,>]+)([,>])");
 			}
 
 			pos = ppvalue_re.search(buf, pos);
@@ -156,7 +156,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 		//		[0]="hello"
 		//		[1]=#"goodbye"
 		//
-		QRegExp pparray_re("\\s*([^=]+)=([^\\n]+)\\n");
+		TQRegExp pparray_re("\\s*([^=]+)=([^\\n]+)\\n");
 		
 		pos = pparray_re.search(buf);
 			
@@ -186,7 +186,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 		//		["greeting"]="hello"
 		//		["farewell"]="goodbye"
 		//
-		QRegExp pphash_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n");
+		TQRegExp pphash_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n");
 		pos = pphash_re.search(buf);
 		
 		while (pos != -1) {
@@ -211,8 +211,8 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 		//		@sleeper=#<Thread:0x3008fd18 sleep>,
 		//		@temp={"z"=>"zed", "p"=>"pee"}>
 		//
-		QRegExp ppstruct_re("(#<Struct::\\w+)\\s([^\\n>]*)(>?)");
-		QRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]");
+		TQRegExp ppstruct_re("(#<Struct::\\w+)\\s([^\\n>]*)(>?)");
+		TQRegExp ppvalue_re("\\s*([^\\n\\s=]+)=([^\\n]+)[,>]");
 	
 		pos = ppstruct_re.search(buf);
 		if (pos != -1) {
@@ -252,7 +252,7 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 		//		[0..11]=0x89504e470d0a1a0a0000000d
 		//		[12..23]=0x494844520000001600000016
 		//
-		QRegExp ppstring_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n");
+		TQRegExp ppstring_re("\\s*(\\[[^\\]]+\\])=([^\\n]+)\\n");
 		pos = ppstring_re.search(buf);
 		
 		while (pos != -1) {
@@ -278,8 +278,8 @@ void RDBParser::parseExpandedVariable(VarItem *parent, char *buf)
 
 // **************************************************************************
 
-void RDBParser::setItem(LazyFetchItem *parent, const QString &varName,
-                        DataType dataType, const QCString &value)
+void RDBParser::setItem(LazyFetchItem *parent, const TQString &varName,
+                        DataType dataType, const TQCString &value)
 {
 	VarItem *item = parent->findItem(varName);
     if (item == 0) {
@@ -315,9 +315,9 @@ void RDBParser::setItem(LazyFetchItem *parent, const QString &varName,
 
 DataType RDBParser::determineType(char *buf)
 {
-	QRegExp array_re("(Array \\(\\d+ element\\(s\\)\\))");
-	QRegExp hash_re("(Hash \\(\\d+ element\\(s\\)\\))");
-	QRegExp string_re("(String \\(length \\d+\\))");
+	TQRegExp array_re("(Array \\(\\d+ element\\(s\\)\\))");
+	TQRegExp hash_re("(Hash \\(\\d+ element\\(s\\)\\))");
+	TQRegExp string_re("(String \\(length \\d+\\))");
 	
 	if (qstrncmp(buf, "#<struct", strlen("#<struct")) == 0) {
 		return STRUCT_TYPE;
diff --git a/languages/ruby/debugger/rdbparser.h b/languages/ruby/debugger/rdbparser.h
index 12bc937e..d57e25d7 100644
--- a/languages/ruby/debugger/rdbparser.h
+++ b/languages/ruby/debugger/rdbparser.h
@@ -32,8 +32,8 @@ namespace RDBParser
     void parseVariables(LazyFetchItem *parent, char *buf);
     void parseExpandedVariable(VarItem *parent, char *buf);
     DataType determineType(char *buf);
-    void setItem(	LazyFetchItem *parent, const QString &varName, 
-					DataType dataType, const QCString &value );
+    void setItem(	LazyFetchItem *parent, const TQString &varName, 
+					DataType dataType, const TQCString &value );
 }
 
 }
diff --git a/languages/ruby/debugger/rdbtable.cpp b/languages/ruby/debugger/rdbtable.cpp
index 2f470b2d..31b7b6d2 100644
--- a/languages/ruby/debugger/rdbtable.cpp
+++ b/languages/ruby/debugger/rdbtable.cpp
@@ -18,13 +18,13 @@
 
 namespace RDBDebugger {
 
-RDBTable::RDBTable(QWidget *parent, const char *name)
- : QTable(parent, name)
+RDBTable::RDBTable(TQWidget *parent, const char *name)
+ : TQTable(parent, name)
 {
 }
 
-RDBTable::RDBTable(int nr, int nc, QWidget * parent, const char * name)
- : QTable(nr, nc, parent, name)
+RDBTable::RDBTable(int nr, int nc, TQWidget * parent, const char * name)
+ : TQTable(nr, nc, parent, name)
 {
 }
 
@@ -32,7 +32,7 @@ RDBTable::~RDBTable()
 {
 }
 
-void RDBTable::keyPressEvent( QKeyEvent * e )
+void RDBTable::keyPressEvent( TQKeyEvent * e )
 {
     emit keyPressed(e->key());
 
@@ -40,12 +40,12 @@ void RDBTable::keyPressEvent( QKeyEvent * e )
         emit returnPressed();
     else if (e->key() == Key_F2)
         emit f2Pressed();
-    else if ((e->text() == QString("a")) && (e->state() == AltButton))
+    else if ((e->text() == TQString("a")) && (e->state() == AltButton))
     {
         emit insertPressed();
         return;
     }
-    else if ((e->text() == QString("A")) && (e->state() == AltButton))
+    else if ((e->text() == TQString("A")) && (e->state() == AltButton))
     {
         emit insertPressed();
         return;
@@ -53,7 +53,7 @@ void RDBTable::keyPressEvent( QKeyEvent * e )
     else if (e->key() == Key_Delete)
         emit deletePressed();
 
-    QTable::keyPressEvent(e);
+    TQTable::keyPressEvent(e);
 }
 
 }
diff --git a/languages/ruby/debugger/rdbtable.h b/languages/ruby/debugger/rdbtable.h
index 04f47c2b..714605d0 100644
--- a/languages/ruby/debugger/rdbtable.h
+++ b/languages/ruby/debugger/rdbtable.h
@@ -16,7 +16,7 @@
 #ifndef RDBDEBUGGERRDBTABLE_H
 #define RDBDEBUGGERRDBTABLE_H
 
-#include <qtable.h>
+#include <tqtable.h>
 
 namespace RDBDebugger {
 
@@ -24,11 +24,11 @@ class RDBTable : public QTable
 {
 Q_OBJECT
 public:
-    RDBTable(QWidget *parent = 0, const char *name = 0);
-    RDBTable( int numRows, int numCols, QWidget * parent = 0, const char * name = 0 );
+    RDBTable(TQWidget *parent = 0, const char *name = 0);
+    RDBTable( int numRows, int numCols, TQWidget * parent = 0, const char * name = 0 );
     ~RDBTable();
 
-    virtual void keyPressEvent ( QKeyEvent * e );
+    virtual void keyPressEvent ( TQKeyEvent * e );
 
 signals:
     void keyPressed(int key);
diff --git a/languages/ruby/debugger/stty.cpp b/languages/ruby/debugger/stty.cpp
index 44cb3795..4316da50 100644
--- a/languages/ruby/debugger/stty.cpp
+++ b/languages/ruby/debugger/stty.cpp
@@ -58,10 +58,10 @@
 #include <bsdtty.h>
 #endif
 
-#include <qintdict.h>
-#include <qsocketnotifier.h>
-#include <qstring.h>
-#include <qfile.h>
+#include <tqintdict.h>
+#include <tqsocketnotifier.h>
+#include <tqstring.h>
+#include <tqfile.h>
 
 #include <klocale.h>
 #include <kstandarddirs.h>
@@ -91,8 +91,8 @@ static int chownpty(int fd, int grant)
         if (fd != PTY_FILENO && dup2(fd, PTY_FILENO) < 0)
             ::exit(1);
 
-        QString path = locate("exe", BASE_CHOWN);
-        execle(QFile::encodeName(path), BASE_CHOWN, grant?"--grant":"--revoke", (void *)0, NULL);
+        TQString path = locate("exe", BASE_CHOWN);
+        execle(TQFile::encodeName(path), BASE_CHOWN, grant?"--grant":"--revoke", (void *)0, NULL);
         ::exit(1); // should not be reached
     }
     if (pid > 0) {
@@ -117,8 +117,8 @@ static int chownpty(int fd, int grant)
 
 // **************************************************************************
 
-STTY::STTY(bool ext, const QString &termAppName)
-    : QObject(),
+STTY::STTY(bool ext, const TQString &termAppName)
+    : TQObject(),
       out(0),
       err(0),
       ttySlave(""),
@@ -129,9 +129,9 @@ STTY::STTY(bool ext, const QString &termAppName)
     } else {
         fout = findTTY();
         if (fout >= 0) {
-            ttySlave = QString(tty_slave);
-            out = new QSocketNotifier(fout, QSocketNotifier::Read, this);
-            connect( out, SIGNAL(activated(int)), this, SLOT(OutReceived(int)) );
+            ttySlave = TQString(tty_slave);
+            out = new TQSocketNotifier(fout, TQSocketNotifier::Read, this);
+            connect( out, TQT_SIGNAL(activated(int)), this, TQT_SLOT(OutReceived(int)) );
         }
     }
 }
@@ -270,9 +270,9 @@ void STTY::OutReceived(int f)
 
 #define FIFO_FILE "/tmp/debug_tty.XXXXXX"
 
-bool STTY::findExternalTTY(const QString &termApp)
+bool STTY::findExternalTTY(const TQString &termApp)
 {
-    QString appName(termApp.isEmpty() ? QString("xterm") : termApp);
+    TQString appName(termApp.isEmpty() ? TQString("xterm") : termApp);
 
     char fifo[] = FIFO_FILE;
     int fifo_fd;
@@ -303,8 +303,8 @@ bool STTY::findExternalTTY(const QString &termApp)
          */
 
         const char* prog      = appName.latin1();
-        QString script = QString("tty>") + QString(fifo) +
-            QString(";"                  // fifo name
+        TQString script = TQString("tty>") + TQString(fifo) +
+            TQString(";"                  // fifo name
                     "trap \"\" INT QUIT TSTP;"	  // ignore various signals
                     "exec<&-;exec>&-;"		        // close stdin and stdout
                     "while :;do sleep 3600;done");
diff --git a/languages/ruby/debugger/stty.h b/languages/ruby/debugger/stty.h
index 31c8fbfe..4f42e650 100644
--- a/languages/ruby/debugger/stty.h
+++ b/languages/ruby/debugger/stty.h
@@ -27,8 +27,8 @@
 
 class QSocketNotifier;
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 namespace RDBDebugger
 {
@@ -38,10 +38,10 @@ class STTY : public QObject
     Q_OBJECT
 
 public:
-    STTY(bool ext=false, const QString &termAppName=QString());
+    STTY(bool ext=false, const TQString &termAppName=TQString());
     ~STTY();
 
-    QString getSlave()    { return ttySlave; };
+    TQString getSlave()    { return ttySlave; };
 
 private slots:
     void OutReceived(int);
@@ -52,14 +52,14 @@ signals:
 
 private:
     int findTTY();
-    bool findExternalTTY(const QString &termApp);
+    bool findExternalTTY(const TQString &termApp);
 
 private:
     int fout;
     int ferr;
-    QSocketNotifier *out;
-    QSocketNotifier *err;
-    QString ttySlave;
+    TQSocketNotifier *out;
+    TQSocketNotifier *err;
+    TQString ttySlave;
     int pid_;
 
     char pty_master[50];  // "/dev/ptyxx" | "/dev/ptmx"
diff --git a/languages/ruby/debugger/variablewidget.cpp b/languages/ruby/debugger/variablewidget.cpp
index 0dbdce9a..fd323fd5 100644
--- a/languages/ruby/debugger/variablewidget.cpp
+++ b/languages/ruby/debugger/variablewidget.cpp
@@ -28,18 +28,18 @@
 #include <klineedit.h>
 #include <kdeversion.h>
 
-#include <qheader.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qhbox.h>
-#include <qpainter.h>
-#include <qpushbutton.h>
-#include <qregexp.h>
-#include <qcursor.h>
+#include <tqheader.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqhbox.h>
+#include <tqpainter.h>
+#include <tqpushbutton.h>
+#include <tqregexp.h>
+#include <tqcursor.h>
 #include <klocale.h>
 
-#include <qpoint.h>
-#include <qclipboard.h>
+#include <tqpoint.h>
+#include <tqclipboard.h>
 #include <kapplication.h>
 
 // **************************************************************************
@@ -49,30 +49,30 @@
 namespace RDBDebugger
 {
 
-VariableWidget::VariableWidget(QWidget *parent, const char *name)
-    : QWidget(parent, name)
+VariableWidget::VariableWidget(TQWidget *parent, const char *name)
+    : TQWidget(parent, name)
 {
     varTree_ = new VariableTree(this);
-    QLabel *label = new QLabel(i18n("E&xpression to watch:"), this);
+    TQLabel *label = new TQLabel(i18n("E&xpression to watch:"), this);
 
-    QHBox *watchEntry = new QHBox( this );
+    TQHBox *watchEntry = new TQHBox( this );
     watchVarEditor_ = new KHistoryCombo( watchEntry, "var-to-watch editor");
     label->setBuddy(watchVarEditor_);
 
-    QPushButton *addButton = new QPushButton(i18n("&Add"), watchEntry );
+    TQPushButton *addButton = new TQPushButton(i18n("&Add"), watchEntry );
     addButton->adjustSize();
     addButton->setFixedWidth(addButton->width());
 
-    QBoxLayout * vbox = new QVBoxLayout();
+    TQBoxLayout * vbox = new TQVBoxLayout();
     vbox->addWidget( label );
     vbox->addWidget( watchEntry );
 
-    QVBoxLayout *topLayout = new QVBoxLayout(this, 2);
+    TQVBoxLayout *topLayout = new TQVBoxLayout(this, 2);
     topLayout->addWidget(varTree_, 10);
     topLayout->addLayout( vbox );
 
-    connect( addButton, SIGNAL(clicked()), SLOT(slotAddWatchExpression()) );
-    connect( watchVarEditor_, SIGNAL(returnPressed()), SLOT(slotAddWatchExpression()) );
+    connect( addButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddWatchExpression()) );
+    connect( watchVarEditor_, TQT_SIGNAL(returnPressed()), TQT_SLOT(slotAddWatchExpression()) );
 }
 
 
@@ -80,7 +80,7 @@ VariableWidget::VariableWidget(QWidget *parent, const char *name)
 
 void VariableWidget::setEnabled(bool bEnabled)
 {
-    QWidget::setEnabled(bEnabled);
+    TQWidget::setEnabled(bEnabled);
     if (bEnabled && parentWidget() != 0) {
         varTree_->setColumnWidth(0, parentWidget()->width()/2);
 	}
@@ -89,7 +89,7 @@ void VariableWidget::setEnabled(bool bEnabled)
 
 void VariableWidget::slotAddWatchExpression()
 {
-    QString watchVar(watchVarEditor_->currentText());
+    TQString watchVar(watchVarEditor_->currentText());
     if (!watchVar.isEmpty()) {
         slotAddWatchExpression(watchVar);
     }
@@ -97,7 +97,7 @@ void VariableWidget::slotAddWatchExpression()
 
 // **************************************************************************
 
-void VariableWidget::slotAddWatchExpression(const QString &ident)
+void VariableWidget::slotAddWatchExpression(const TQString &ident)
 {
     if (!ident.isEmpty()) {
         watchVarEditor_->addToHistory(ident);
@@ -108,17 +108,17 @@ void VariableWidget::slotAddWatchExpression(const QString &ident)
 
 // **************************************************************************
 
-void VariableWidget::focusInEvent(QFocusEvent */*e*/)
+void VariableWidget::focusInEvent(TQFocusEvent */*e*/)
 {
     varTree_->setFocus();
 }
 
-void VariableWidget::restorePartialProjectSession(const QDomElement* el)
+void VariableWidget::restorePartialProjectSession(const TQDomElement* el)
 {
 	varTree_->watchRoot()->restorePartialProjectSession(el);
 }
 
-void VariableWidget::savePartialProjectSession(QDomElement* el)
+void VariableWidget::savePartialProjectSession(TQDomElement* el)
 {
 	varTree_->watchRoot()->savePartialProjectSession(el);
 }
@@ -129,7 +129,7 @@ void VariableWidget::savePartialProjectSession(QDomElement* el)
 
 VariableTree::VariableTree(VariableWidget *parent, const char *name)
     : KListView(parent, name),
-      QToolTip( viewport() ),
+      TQToolTip( viewport() ),
       activationId_(0),
       currentThread_(-1),
 	  selectedFrame_(0),
@@ -140,16 +140,16 @@ VariableTree::VariableTree(VariableWidget *parent, const char *name)
     setAllColumnsShowFocus(true);
     setColumnWidthMode(0, Manual);
     setSorting(VAR_NAME_COLUMN);
-    QListView::setSelectionMode(QListView::Single);
+    TQListView::setSelectionMode(TQListView::Single);
 
     addColumn(i18n("Variable"), 100 );
     addColumn(i18n("Value"), 100 );
 
-    connect( this, SIGNAL(contextMenu(KListView*, QListViewItem*, const QPoint&)),
-             SLOT(slotContextMenu(KListView*, QListViewItem*)) );
+    connect( this, TQT_SIGNAL(contextMenu(KListView*, TQListViewItem*, const TQPoint&)),
+             TQT_SLOT(slotContextMenu(KListView*, TQListViewItem*)) );
     
-	connect( this, SIGNAL(pressed(QListViewItem*)),
-             this, SLOT(slotPressed(QListViewItem*)) );
+	connect( this, TQT_SIGNAL(pressed(TQListViewItem*)),
+             this, TQT_SLOT(slotPressed(TQListViewItem*)) );
 
 	watchRoot_ = new WatchRoot(this);
 }
@@ -164,9 +164,9 @@ VariableTree::~VariableTree()
 
 void VariableTree::clear()
 {
-    QListViewItem *sibling = firstChild();
+    TQListViewItem *sibling = firstChild();
     while (sibling != 0) {
-		QListViewItem * current = sibling;
+		TQListViewItem * current = sibling;
 		sibling = sibling->nextSibling();
 		if (current->rtti() != RTTI_WATCH_ROOT) {
 			delete current;
@@ -180,7 +180,7 @@ void VariableTree::clear()
 
 // **************************************************************************
 
-void VariableTree::slotContextMenu(KListView *, QListViewItem *item)
+void VariableTree::slotContextMenu(KListView *, TQListViewItem *item)
 {
     if (item == 0)
         return;
@@ -196,14 +196,14 @@ void VariableTree::slotContextMenu(KListView *, QListViewItem *item)
 		}
 
         int	idCopyToClipboard = popup.insertItem( i18n("Copy to Clipboard") );
-        int res = popup.exec(QCursor::pos());
+        int res = popup.exec(TQCursor::pos());
 
         if (res == idRemoveWatch) {
 			emit removeWatchExpression(((WatchVarItem*)item)->displayId());
             delete item;
         } else if (res == idCopyToClipboard) {
             QClipboard *qb = KApplication::clipboard();
-            QString text = "{ \"" + item->text( VAR_NAME_COLUMN ) + "\", " +
+            TQString text = "{ \"" + item->text( VAR_NAME_COLUMN ) + "\", " +
                             "\"" + item->text( VALUE_COLUMN ) + "\" }";
 
             qb->setText( text, QClipboard::Clipboard );
@@ -213,20 +213,20 @@ void VariableTree::slotContextMenu(KListView *, QListViewItem *item)
 
 /***************************************************************************/
 
-void VariableTree::setSelected(QListViewItem * item, bool selected)
+void VariableTree::setSelected(TQListViewItem * item, bool selected)
 {
 	// Save the last selected VarFrameRoot for slotPressed() to restore
 	if (item->rtti() == RTTI_VAR_FRAME_ROOT && selected) {
 		selectedFrame_ = (VarFrameRoot *) item;
 	}
 	
-	QListView::setSelected(item, selected);
+	TQListView::setSelected(item, selected);
 }
 
 /***************************************************************************/
 
 // Makes sure that only VarFrameRoot items can be selected
-void VariableTree::slotPressed(QListViewItem * item)
+void VariableTree::slotPressed(TQListViewItem * item)
 {
 	if (item == 0) {
 		return;
@@ -258,10 +258,10 @@ void VariableTree::slotPressed(QListViewItem * item)
 
 void VariableTree::prune()
 {
-	QListViewItem *child = firstChild();
+	TQListViewItem *child = firstChild();
 
     while (child != 0) {
-        QListViewItem *nextChild = child->nextSibling();
+        TQListViewItem *nextChild = child->nextSibling();
 
         // Only prune var frames, not the watch or global root
         if (child->rtti() == RTTI_VAR_FRAME_ROOT) {
@@ -298,7 +298,7 @@ void VariableTree::nextActivationId()
 //
 // After that, any frames which aren't marked as active must have gone
 // out of scope and will end up pruned.
-void VariableTree::slotFrameActive(int frameNo, int threadNo, const QString& frameName)
+void VariableTree::slotFrameActive(int frameNo, int threadNo, const TQString& frameName)
 {
 	VarFrameRoot * frame = findFrame(frameNo, threadNo);
 	if (frameNo == 1) {
@@ -319,7 +319,7 @@ void VariableTree::slotFrameActive(int frameNo, int threadNo, const QString& fra
 
 bool VariableTree::schedule()
 {
-    QListViewItem *	child = firstChild();
+    TQListViewItem *	child = firstChild();
 	VarFrameRoot * frame = 0;
 
     while (child != 0) {
@@ -328,8 +328,8 @@ bool VariableTree::schedule()
 			Q_ASSERT( !frame->isWaitingForData() );
 			
 			if (frame->needsVariables()) {
-				if (QApplication::overrideCursor() == 0) {
-					QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+				if (TQApplication::overrideCursor() == 0) {
+					TQApplication::setOverrideCursor(TQCursor(Qt::WaitCursor));
 				}
 				
 				// Tell the controller to fetch the variable values
@@ -348,7 +348,7 @@ bool VariableTree::schedule()
 	// All over, nothing left to fetch. 
 	// Return to frame 1, and prune the inactive items
 	// from the variable tree..
-	QApplication::restoreOverrideCursor();
+	TQApplication::restoreOverrideCursor();
 	emit selectFrame(1, currentThread_);
 	prune();
 	
@@ -357,7 +357,7 @@ bool VariableTree::schedule()
 
 // **************************************************************************
 
-void VariableTree::slotAddWatchExpression(const QString &watchVar)
+void VariableTree::slotAddWatchExpression(const TQString &watchVar)
 {
     new WatchVarItem(watchRoot(), watchVar, UNKNOWN_TYPE);
 	emit addWatchExpression(watchVar, true);
@@ -377,7 +377,7 @@ VarFrameRoot *VariableTree::findFrame(int frameNo, int threadNo) const
 {
     // frames only exist on the top level so we only need to
     // check the siblings
-    QListViewItem *sibling = firstChild();
+    TQListViewItem *sibling = firstChild();
     while (sibling != 0) {
 		if (	sibling->rtti() == RTTI_VAR_FRAME_ROOT
 				&& ((VarFrameRoot*) sibling)->frameNo() == frameNo 
@@ -416,7 +416,7 @@ GlobalRoot *VariableTree::globalRoot()
 // so tell the controller about any already in the tree at start.
 void VariableTree::resetWatchVars()
 {
-	for (QListViewItem *child = watchRoot()->firstChild(); child != 0; child = child->nextSibling()) {
+	for (TQListViewItem *child = watchRoot()->firstChild(); child != 0; child = child->nextSibling()) {
 		((WatchVarItem*) child)->setDisplayId(-1);
         emit addWatchExpression(child->text(VAR_NAME_COLUMN), false);
 	}
@@ -424,11 +424,11 @@ void VariableTree::resetWatchVars()
 
 // **************************************************************************
 
-void VariableTree::maybeTip(const QPoint &p)
+void VariableTree::maybeTip(const TQPoint &p)
 {
     VarItem * item = dynamic_cast<VarItem*>( itemAt(p) );
     if (item != 0) {
-        QRect r = itemRect(item);
+        TQRect r = itemRect(item);
         if (r.isValid()) {
             tip(r, item->tipText());
 		}
@@ -466,7 +466,7 @@ LazyFetchItem::~LazyFetchItem()
 
 // **************************************************************************
 
-void LazyFetchItem::paintCell(QPainter *p, const QColorGroup &cg,
+void LazyFetchItem::paintCell(TQPainter *p, const TQColorGroup &cg,
                               int column, int width, int align)
 {
     if (p == 0) {
@@ -475,19 +475,19 @@ void LazyFetchItem::paintCell(QPainter *p, const QColorGroup &cg,
 	
     // make toplevel item (watch and frame items) names bold
     if (column == VAR_NAME_COLUMN && parent() == 0) {
-        QFont f = p->font();
+        TQFont f = p->font();
         f.setBold(true);
         p->setFont(f);
     }
 	
-    QListViewItem::paintCell( p, cg, column, width, align );
+    TQListViewItem::paintCell( p, cg, column, width, align );
 }
 
 // **************************************************************************
 
-VarItem *LazyFetchItem::findItem(const QString &name) const
+VarItem *LazyFetchItem::findItem(const TQString &name) const
 {
-	QListViewItem *child = firstChild();
+	TQListViewItem *child = firstChild();
 
     // Check the siblings on this branch
     while (child != 0) {
@@ -505,7 +505,7 @@ VarItem *LazyFetchItem::findItem(const QString &name) const
 
 void LazyFetchItem::prune()
 {
-    QListViewItem *child = firstChild();
+    TQListViewItem *child = firstChild();
 
     while (child != 0) {
         LazyFetchItem *item = (LazyFetchItem*) child;
@@ -526,9 +526,9 @@ void LazyFetchItem::prune()
 // **************************************************************************
 // **************************************************************************
 
-VarItem::VarItem(LazyFetchItem *parent, const QString &varName, DataType dataType)
+VarItem::VarItem(LazyFetchItem *parent, const TQString &varName, DataType dataType)
     : LazyFetchItem (parent),
-      cache_(QCString()),
+      cache_(TQCString()),
       dataType_(dataType),
       highlight_(false)
 {
@@ -542,14 +542,14 @@ VarItem::VarItem(LazyFetchItem *parent, const QString &varName, DataType dataTyp
 	// Matches either an array element or a string slice,
 	// Order on the array index or the first number in the
 	// range specifying the slice.
-	QRegExp arrayelement_re("\\[(\\d+)(\\.\\.\\d+)?\\]");
+	TQRegExp arrayelement_re("\\[(\\d+)(\\.\\.\\d+)?\\]");
 	key_ = varName;
 	
 	if (arrayelement_re.search(varName) != -1) {
 		key_.sprintf("%.6d", arrayelement_re.cap(1).toInt());
 	} else if (key_.startsWith("$")) {
 		key_.prepend("1001");		// Global variable
-	} else if (QRegExp("^[A-Z]").search(varName) != -1) {
+	} else if (TQRegExp("^[A-Z]").search(varName) != -1) {
 		key_.prepend("1002");		// Constant
 	} else if (key_.startsWith("@@")) {
 		key_.prepend("1003");		// Class variable
@@ -568,7 +568,7 @@ VarItem::~VarItem()
 {
 }
 
-QString VarItem::key(int /*column*/, bool /*ascending*/) const 
+TQString VarItem::key(int /*column*/, bool /*ascending*/) const 
 {
 	return key_;
 }
@@ -580,10 +580,10 @@ QString VarItem::key(int /*column*/, bool /*ascending*/) const
 // For example, @foobar within instance obj is accessed as obj.foobar.
 // But don't strip off the @ for an instance variable with no path,
 // and leave a plain '@foobar' as it is.
-QString VarItem::fullName() const
+TQString VarItem::fullName() const
 {
-	QString itemName = text(VAR_NAME_COLUMN);
-    QString vPath("");
+	TQString itemName = text(VAR_NAME_COLUMN);
+    TQString vPath("");
     const VarItem *item = this;
 
 	if (item->parent()->rtti() != RTTI_VAR_ITEM) {
@@ -592,7 +592,7 @@ QString VarItem::fullName() const
 
     // This stops at the root item (FrameRoot or GlobalRoot)
 	while (item->rtti() == RTTI_VAR_ITEM) {
-		QString itemName = item->text(VAR_NAME_COLUMN);
+		TQString itemName = item->text(VAR_NAME_COLUMN);
 		
 		if (vPath.startsWith("[")) {
 			// If it's a Hash or an Array, then just insert the value. As
@@ -609,15 +609,15 @@ QString VarItem::fullName() const
     }
 
 	// Change 'self.@foobar' to '@foobar'
-	vPath.replace(QRegExp("^self\\.@"), "@");
+	vPath.replace(TQRegExp("^self\\.@"), "@");
 	
 	// Use instance_variable_get() to access any '@var's in the middle of a path	
-	QRegExp re_instance_var("\\.(@[^\\[.]+)");
+	TQRegExp re_instance_var("\\.(@[^\\[.]+)");
 	int pos = re_instance_var.search(vPath);	
 	while (pos != -1) {	
 		vPath.replace(	pos, 
 						re_instance_var.matchedLength(), 
-						QString(".instance_variable_get(:") + re_instance_var.cap(1) + ")" );
+						TQString(".instance_variable_get(:") + re_instance_var.cap(1) + ")" );
 		pos = re_instance_var.search(vPath, pos);	
 	}		
 
@@ -626,7 +626,7 @@ QString VarItem::fullName() const
 
 // **************************************************************************
 
-void VarItem::setText(int column, const QString &data)
+void VarItem::setText(int column, const TQString &data)
 {
 	setActivationId();
 	
@@ -634,7 +634,7 @@ void VarItem::setText(int column, const QString &data)
 		highlight_ = (!text(VALUE_COLUMN).isEmpty() && text(VALUE_COLUMN) != data);
     }
 
-    QListViewItem::setText(column, data);
+    TQListViewItem::setText(column, data);
     repaint();
 }
 
@@ -650,7 +650,7 @@ void VarItem::expandValue(char *buf)
 
 void VarItem::setOpen(bool open)
 {
-    QListViewItem::setOpen(open);
+    TQListViewItem::setOpen(open);
 	
 	Q_ASSERT(	dataType_ == REFERENCE_TYPE 
 				|| dataType_ == ARRAY_TYPE 
@@ -692,7 +692,7 @@ void VarItem::setDataType(DataType dataType)
 // **************************************************************************
 
 // Overridden to highlight the changed items
-void VarItem::paintCell(QPainter *p, const QColorGroup &cg,
+void VarItem::paintCell(TQPainter *p, const TQColorGroup &cg,
                         int column, int width, int align)
 {
     if (p == 0) {
@@ -703,37 +703,37 @@ void VarItem::paintCell(QPainter *p, const QColorGroup &cg,
 		// Show color values as colors, and make the text color the same
 		// as the base color
 		if (dataType_ == COLOR_TYPE) {
-			QRegExp color_re("\\s(#.*)>");
+			TQRegExp color_re("\\s(#.*)>");
 			
 			if (color_re.search(text(column)) != -1) {
-        		QColorGroup color_cg(	cg.foreground(), cg.background(), 
+        		TQColorGroup color_cg(	cg.foreground(), cg.background(), 
 										cg.light(), cg.dark(), cg.mid(), 
-										QColor(color_re.cap(1)), QColor(color_re.cap(1)) );
-        		QListViewItem::paintCell(p, color_cg, column, width, align);
+										TQColor(color_re.cap(1)), TQColor(color_re.cap(1)) );
+        		TQListViewItem::paintCell(p, color_cg, column, width, align);
 				return;
 			}
 		}
 		
 		// Highlight recently changed items in red
 		if (highlight_) {
-        	QColorGroup hl_cg(	cg.foreground(), cg.background(), 
+        	TQColorGroup hl_cg(	cg.foreground(), cg.background(), 
 								cg.light(), cg.dark(), cg.mid(), 
 								red, cg.base() );
-        	QListViewItem::paintCell(p, hl_cg, column, width, align);
+        	TQListViewItem::paintCell(p, hl_cg, column, width, align);
 			return;
 		}
 	}
 	
-	QListViewItem::paintCell(p, cg, column, width, align);
+	TQListViewItem::paintCell(p, cg, column, width, align);
 	return;
 }
 
 // **************************************************************************
 
-QString VarItem::tipText() const
+TQString VarItem::tipText() const
 {
     const unsigned int MAX_TOOLTIP_SIZE = 70;
-    QString tip = text(VALUE_COLUMN);
+    TQString tip = text(VALUE_COLUMN);
 
     if (tip.length() < MAX_TOOLTIP_SIZE) {
 	    return tip;
@@ -789,7 +789,7 @@ void VarFrameRoot::setLocals()
 void VarFrameRoot::setOpen(bool open)
 {
 	bool localsViewChanged = (isOpen() != open);
-    QListViewItem::setOpen(open);
+    TQListViewItem::setOpen(open);
 	
     if (localsViewChanged) {
 		((VariableTree*)listView())->selectFrame(frameNo_, threadNo_);
@@ -798,7 +798,7 @@ void VarFrameRoot::setOpen(bool open)
 	return;
 }
 
-void VarFrameRoot::setFrameName(const QString &frameName)
+void VarFrameRoot::setFrameName(const TQString &frameName)
 {
 	setText(VAR_NAME_COLUMN, frameName); 
 	setText(VALUE_COLUMN, "");
@@ -858,7 +858,7 @@ void GlobalRoot::setGlobals(char * globals)
 void GlobalRoot::setOpen(bool open)
 {
 	bool globalsViewChanged = (isOpen() != open);
-	QListViewItem::setOpen(open);
+	TQListViewItem::setOpen(open);
 	
 	if (globalsViewChanged) {
     	((VariableTree*)listView())->setFetchGlobals(isOpen());
@@ -872,7 +872,7 @@ void GlobalRoot::setOpen(bool open)
 // **************************************************************************
 // **************************************************************************
 
-WatchVarItem::WatchVarItem( LazyFetchItem *parent, const QString &varName, DataType dataType, int displayId )
+WatchVarItem::WatchVarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType, int displayId )
     : VarItem(parent, varName, dataType),
 	displayId_(displayId)
 {
@@ -923,10 +923,10 @@ WatchRoot::~WatchRoot()
 // display id
 void WatchRoot::setWatchExpression(char * buf, char * expression)
 {
-	QString expr(expression);
-	QRegExp display_re("^(\\d+):\\s([^\n]+)\n");
+	TQString expr(expression);
+	TQRegExp display_re("^(\\d+):\\s([^\n]+)\n");
 	
-    for (	QListViewItem *child = firstChild(); 
+    for (	TQListViewItem *child = firstChild(); 
 			child != 0; 
 			child = child->nextSibling() ) 
 	{
@@ -946,9 +946,9 @@ void WatchRoot::setWatchExpression(char * buf, char * expression)
 
 // After a program pause, this updates the new value of a Watch item
 // expr is the thing = value part of "1: a = 1", id is the display number
-void WatchRoot::updateWatchExpression(int id, const QString& expr)
+void WatchRoot::updateWatchExpression(int id, const TQString& expr)
 {
-    for (	QListViewItem *child = firstChild(); 
+    for (	TQListViewItem *child = firstChild(); 
 			child != 0; 
 			child = child->nextSibling() ) 
 	{
@@ -963,20 +963,20 @@ void WatchRoot::updateWatchExpression(int id, const QString& expr)
 	}
 }
 
-void WatchRoot::savePartialProjectSession(QDomElement* el)
+void WatchRoot::savePartialProjectSession(TQDomElement* el)
 {
-    QDomDocument domDoc = el->ownerDocument();
+    TQDomDocument domDoc = el->ownerDocument();
     if (domDoc.isNull()) {
         return;
 	}
 	
-    QDomElement watchEl = domDoc.createElement("watchExpressions");
+    TQDomElement watchEl = domDoc.createElement("watchExpressions");
     
-	for (	QListViewItem *child = firstChild(); 
+	for (	TQListViewItem *child = firstChild(); 
 			child != 0; 
 			child = child->nextSibling() )
 	{
-        QDomElement subEl = domDoc.createElement("el");
+        TQDomElement subEl = domDoc.createElement("el");
         subEl.appendChild(domDoc.createTextNode(child->text(VAR_NAME_COLUMN)));
         watchEl.appendChild(subEl);
 	}
@@ -988,15 +988,15 @@ void WatchRoot::savePartialProjectSession(QDomElement* el)
 	return;
 }
 
-void WatchRoot::restorePartialProjectSession(const QDomElement* el)
+void WatchRoot::restorePartialProjectSession(const TQDomElement* el)
 {
-    QDomDocument domDoc = el->ownerDocument();
+    TQDomDocument domDoc = el->ownerDocument();
     if (domDoc.isNull()) {
         return;
 	}
 	
-    QDomElement watchEl = el->namedItem("watchExpressions").toElement();
-    QDomElement subEl = watchEl.firstChild().toElement();
+    TQDomElement watchEl = el->namedItem("watchExpressions").toElement();
+    TQDomElement subEl = watchEl.firstChild().toElement();
 	
     while (!subEl.isNull()) {
 		new WatchVarItem(this, subEl.firstChild().toText().data(), UNKNOWN_TYPE);
diff --git a/languages/ruby/debugger/variablewidget.h b/languages/ruby/debugger/variablewidget.h
index c608ec45..4104ae93 100644
--- a/languages/ruby/debugger/variablewidget.h
+++ b/languages/ruby/debugger/variablewidget.h
@@ -26,8 +26,8 @@
 
 #include <klistview.h>
 #include <kcombobox.h>
-#include <qwidget.h>
-#include <qtooltip.h>
+#include <tqwidget.h>
+#include <tqtooltip.h>
 #include <kdebug.h>
 
 class KLineEdit;
@@ -65,22 +65,22 @@ class VariableWidget : public QWidget
     Q_OBJECT
 
 public:
-    VariableWidget( QWidget *parent=0, const char *name=0 );
+    VariableWidget( TQWidget *parent=0, const char *name=0 );
 
     VariableTree *varTree() const
     { return varTree_; }
 
     virtual void setEnabled(bool b);
 	
-	void restorePartialProjectSession(const QDomElement* el);
-	void savePartialProjectSession(QDomElement* el);
+	void restorePartialProjectSession(const TQDomElement* el);
+	void savePartialProjectSession(TQDomElement* el);
 
 protected:
-    virtual void focusInEvent(QFocusEvent *e);
+    virtual void focusInEvent(TQFocusEvent *e);
 
 public slots:
     void slotAddWatchExpression();
-    void slotAddWatchExpression(const QString &expr);
+    void slotAddWatchExpression(const TQString &expr);
 
 private:
     VariableTree *varTree_;
@@ -129,26 +129,26 @@ public:
 	// values of the global variables
     void setFetchGlobals(bool fetch);
 
-	// (from QToolTip) Display a tooltip when the cursor is over an item
-	virtual void maybeTip(const QPoint &);
+	// (from TQToolTip) Display a tooltip when the cursor is over an item
+	virtual void maybeTip(const TQPoint &);
 	
-	virtual void setSelected(QListViewItem * item, bool selected);
+	virtual void setSelected(TQListViewItem * item, bool selected);
 
 signals:
-    void toggleWatchpoint(const QString &varName);
+    void toggleWatchpoint(const TQString &varName);
     void selectFrame(int frame, int thread);
-    void expandItem(VarItem *item, const QCString &request);
+    void expandItem(VarItem *item, const TQCString &request);
     void fetchGlobals(bool fetch);
-    void addWatchExpression(const QString& expr, bool execute);
+    void addWatchExpression(const TQString& expr, bool execute);
     void removeWatchExpression(int displayId);
 
 public slots:
-    void slotAddWatchExpression(const QString& watchVar);
-    void slotFrameActive(int frameNo, int threadNo, const QString& frameName);
-    void slotPressed(QListViewItem * item);	
+    void slotAddWatchExpression(const TQString& watchVar);
+    void slotFrameActive(int frameNo, int threadNo, const TQString& frameName);
+    void slotPressed(TQListViewItem * item);	
 
 private slots:
-    void slotContextMenu(KListView *, QListViewItem *item);
+    void slotContextMenu(KListView *, TQListViewItem *item);
 
 private:
     int activationId_;
@@ -178,7 +178,7 @@ public:
 	virtual int rtti() const { return RTTI_LAZY_FETCH_ITEM; }
 	
     virtual void prune();
-    virtual VarItem *findItem(const QString& name) const;
+    virtual VarItem *findItem(const TQString& name) const;
     
 	int  currentActivationId() const        { return ((VariableTree*) listView())->activationId(); }
 	virtual void setActivationId()          { activationId_ = currentActivationId(); }
@@ -189,7 +189,7 @@ public:
     bool isWaitingForData() const           { return waitingForData_; }
 
 protected:
-    void paintCell( QPainter *p, const QColorGroup &cg,
+    void paintCell( TQPainter *p, const TQColorGroup &cg,
                     int column, int width, int align );
 
 private:
@@ -204,23 +204,23 @@ private:
 class VarItem : public LazyFetchItem
 {
 public:
-    VarItem( LazyFetchItem *parent, const QString &varName, DataType dataType );
+    VarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType );
 
     virtual ~VarItem();
 	
 	virtual int rtti() const { return RTTI_VAR_ITEM; }
-	virtual QString key(int column, bool ascending) const;
+	virtual TQString key(int column, bool ascending) const;
 
-    QString fullName() const;
+    TQString fullName() const;
 	
     DataType dataType() const;
 	void setDataType(DataType dataType);
 
     void setOpen(bool open);
-    void setText (int column, const QString& text);
+    void setText (int column, const TQString& text);
 
     // Returns the text to be displayed as tooltip (the value)
-    QString tipText() const;
+    TQString tipText() const;
 	
 	// If the item is open, fetch details via a pp command
     void update();
@@ -230,12 +230,12 @@ public:
     void expandValue(char *data);
 
 private:
-    void paintCell( QPainter *p, const QColorGroup &cg,
+    void paintCell( TQPainter *p, const TQColorGroup &cg,
                     int column, int width, int align );
 
 private:
-	QString   key_;
-    QCString  cache_;
+	TQString   key_;
+    TQCString  cache_;
     DataType  dataType_;
     bool      highlight_;
 };
@@ -247,7 +247,7 @@ private:
 class WatchVarItem : public VarItem
 {
 public:
-    WatchVarItem( LazyFetchItem *parent, const QString &varName, DataType dataType, int displayId = -1);
+    WatchVarItem( LazyFetchItem *parent, const TQString &varName, DataType dataType, int displayId = -1);
 
     virtual ~WatchVarItem();
 	
@@ -273,15 +273,15 @@ public:
 	
 	virtual int rtti() const { return RTTI_VAR_FRAME_ROOT; }
 	
-	virtual QString key(int column, bool /*ascending*/) const {
-		return QString("%1%2").arg(RTTI_VAR_FRAME_ROOT).arg(text(column));
+	virtual TQString key(int column, bool /*ascending*/) const {
+		return TQString("%1%2").arg(RTTI_VAR_FRAME_ROOT).arg(text(column));
 	}
 
     void addLocals(char *variables);
     void setLocals();
     void setOpen(bool open);
 
-    void setFrameName(const QString &frameName);
+    void setFrameName(const TQString &frameName);
 
 	virtual void setActivationId();
     bool needsVariables() const;
@@ -293,7 +293,7 @@ private:
     bool    needsVariables_;
     int     frameNo_;
     int     threadNo_;
-    QCString cache_;
+    TQCString cache_;
 };
 
 /***************************************************************************/
@@ -308,15 +308,15 @@ public:
 	
 	virtual int rtti() const { return RTTI_WATCH_ROOT; }
 	
-	virtual QString key(int column, bool /*ascending*/) const {
-		return QString("%1%2").arg(RTTI_WATCH_ROOT).arg(text(column));
+	virtual TQString key(int column, bool /*ascending*/) const {
+		return TQString("%1%2").arg(RTTI_WATCH_ROOT).arg(text(column));
 	}
 
 	void setWatchExpression(char * buf, char * expr);
-	void updateWatchExpression(int id, const QString& expr);
+	void updateWatchExpression(int id, const TQString& expr);
 	
-	void restorePartialProjectSession(const QDomElement* el);
-	void savePartialProjectSession(QDomElement* el);
+	void restorePartialProjectSession(const TQDomElement* el);
+	void savePartialProjectSession(TQDomElement* el);
 };
 
 /***************************************************************************/
@@ -331,8 +331,8 @@ public:
 	
 	virtual int rtti() const { return RTTI_GLOBAL_ROOT; }
 	
-	virtual QString key(int column, bool /*ascending*/) const {
-		return QString("%1%2").arg(RTTI_GLOBAL_ROOT).arg(text(column));
+	virtual TQString key(int column, bool /*ascending*/) const {
+		return TQString("%1%2").arg(RTTI_GLOBAL_ROOT).arg(text(column));
 	}
 	
     void setOpen(bool open);