Trinity Qt initial conversion

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

40 files changed, 618 insertions, 618 deletions

diff --git a/quanta/components/debugger/backtracelistview.cpp b/quanta/components/debugger/backtracelistview.cpp
index aa5c8c95..202e86e0 100644
--- a/quanta/components/debugger/backtracelistview.cpp
+++ b/quanta/components/debugger/backtracelistview.cpp
@@ -49,7 +49,7 @@ BacktraceListviewItem::BacktraceListviewItem(BacktraceListview* view)
 }
 
 
-BacktraceListview::BacktraceListview(QWidget *parent, const char *name)
+BacktraceListview::BacktraceListview(TQWidget *parent, const char *name)
   : KListView(parent, name)
 {
   int charwidth = this->fontMetrics().width("0");
@@ -64,14 +64,14 @@ BacktraceListview::BacktraceListview(QWidget *parent, const char *name)
   setAllColumnsShowFocus(true);
 
   // Jump to bt
-  connect(this, SIGNAL( doubleClicked( QListViewItem *, const QPoint &, int) ), this, SLOT(slotBacktraceDoubleClick( QListViewItem *, const QPoint &, int)));
+  connect(this, TQT_SIGNAL( doubleClicked( TQListViewItem *, const TQPoint &, int) ), this, TQT_SLOT(slotBacktraceDoubleClick( TQListViewItem *, const TQPoint &, int)));
 }
 
 
 BacktraceListview::~BacktraceListview()
 {}
 
-void BacktraceListview::backtraceShow(int level, BacktraceType type, const QString& filename, long line, const QString& func)
+void BacktraceListview::backtraceShow(int level, BacktraceType type, const TQString& filename, long line, const TQString& func)
 {
   BacktraceListviewItem* item = new BacktraceListviewItem(this);
   item->setLevel(level);
@@ -82,14 +82,14 @@ void BacktraceListview::backtraceShow(int level, BacktraceType type, const QStri
   
   item->setText(BacktraceListviewColumns::File, filename);
   item->setText(BacktraceListviewColumns::Function, func);
-  item->setText(BacktraceListviewColumns::Level, QString::number(level));
-  item->setText(BacktraceListviewColumns::Line, QString::number(line + 1));
+  item->setText(BacktraceListviewColumns::Level, TQString::number(level));
+  item->setText(BacktraceListviewColumns::Line, TQString::number(line + 1));
   item->setText(BacktraceListviewColumns::Type, type == File ? i18n("File") : i18n("Eval"));
   
   insertItem(item);
 }
 
-void BacktraceListview::keyPressEvent(QKeyEvent *e)
+void BacktraceListview::keyPressEvent(TQKeyEvent *e)
 {
   if(e->key() != Qt::Key_Enter)
   {
@@ -106,7 +106,7 @@ void BacktraceListview::clear()
   KListView::clear();
 }
 
-void BacktraceListview::slotBacktraceDoubleClick(QListViewItem *item, const QPoint &, int )
+void BacktraceListview::slotBacktraceDoubleClick(TQListViewItem *item, const TQPoint &, int )
 {
   if(!item)
     return;
@@ -114,7 +114,7 @@ void BacktraceListview::slotBacktraceDoubleClick(QListViewItem *item, const QPoi
   jumpHistory(item);
 }
 
-void BacktraceListview::jumpHistory(QListViewItem *item)
+void BacktraceListview::jumpHistory(TQListViewItem *item)
 {
   BacktraceListviewItem* btitem = dynamic_cast<BacktraceListviewItem*>(item);
   
diff --git a/quanta/components/debugger/backtracelistview.h b/quanta/components/debugger/backtracelistview.h
index e00d0afc..21b72d3d 100644
--- a/quanta/components/debugger/backtracelistview.h
+++ b/quanta/components/debugger/backtracelistview.h
@@ -21,7 +21,7 @@
 
 #include <klistview.h>
 #include <kpopupmenu.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
 class BacktraceListview;
 
@@ -37,8 +37,8 @@ class BacktraceListviewItem : public KListViewItem
 {
   private:
     BacktraceType m_type;
-    QString m_filename;
-    QString m_func;
+    TQString m_filename;
+    TQString m_func;
     long m_line;
     long m_level;
 
@@ -51,12 +51,12 @@ class BacktraceListviewItem : public KListViewItem
     void setType(BacktraceType type) { m_type = type; }
 
     // Filename
-    QString filename() const { return m_filename; }
-    void setFilename(const QString &filename) { m_filename = filename; }
+    TQString filename() const { return m_filename; }
+    void setFilename(const TQString &filename) { m_filename = filename; }
     
     // Function
-    QString func() const { return m_func; }
-    void setFunc(const QString &func) { m_func = func; }
+    TQString func() const { return m_func; }
+    void setFunc(const TQString &func) { m_func = func; }
     
     // Line
     long line() const { return m_line; }
@@ -74,19 +74,19 @@ class BacktraceListview : public KListView
 
   public:
 
-    BacktraceListview(QWidget *parent = 0, const char *name = 0);
+    BacktraceListview(TQWidget *parent = 0, const char *name = 0);
     ~BacktraceListview();
 
-    void backtraceShow(int level, BacktraceType type, const QString& filename, long line, const QString& func);
+    void backtraceShow(int level, BacktraceType type, const TQString& filename, long line, const TQString& func);
 
     void clear();
 
   public slots:
-    void slotBacktraceDoubleClick(QListViewItem *item, const QPoint &point, int column);
+    void slotBacktraceDoubleClick(TQListViewItem *item, const TQPoint &point, int column);
 
   private:
-    void keyPressEvent(QKeyEvent *e);
-    void jumpHistory(QListViewItem *item);
+    void keyPressEvent(TQKeyEvent *e);
+    void jumpHistory(TQListViewItem *item);
 
 };
 
diff --git a/quanta/components/debugger/conditionalbreakpointdialog.cpp b/quanta/components/debugger/conditionalbreakpointdialog.cpp
index 943c33d4..055512da 100644
--- a/quanta/components/debugger/conditionalbreakpointdialog.cpp
+++ b/quanta/components/debugger/conditionalbreakpointdialog.cpp
@@ -16,19 +16,19 @@
 
 
 #include "conditionalbreakpointdialog.h"
-#include <qlistview.h>
-#include <qlineedit.h>
+#include <tqlistview.h>
+#include <tqlineedit.h>
 #include <qextfileinfo.h>
-#include <qcolor.h>
+#include <tqcolor.h>
 #include <kcombobox.h>
 #include <kled.h>
 #include <kiconloader.h>
-#include <qpushbutton.h>
-#include <qradiobutton.h>
+#include <tqpushbutton.h>
+#include <tqradiobutton.h>
 
 #include "debuggerbreakpoint.h"
 
-ConditionalBreakpointDialog::ConditionalBreakpointDialog(const QString& expression, const QString& inFile, const QString& inClass, const QString& inFunction)
+ConditionalBreakpointDialog::ConditionalBreakpointDialog(const TQString& expression, const TQString& inFile, const TQString& inClass, const TQString& inFunction)
     : ConditionalBreakpointDialogS(0, "ConditionalBreakpointDialog", false, 0)
 {
   comboExpression->setCurrentText(expression);
@@ -40,11 +40,11 @@ ConditionalBreakpointDialog::ConditionalBreakpointDialog(const QString& expressi
   buttonClearClass->setPixmap(SmallIcon("clear_left"));
   buttonClearFunction->setPixmap(SmallIcon("clear_left"));
   
-  connect(comboExpression, SIGNAL(textChanged(const QString&)), this, SLOT(slotExpressionChanged()));
+  connect(comboExpression, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotExpressionChanged()));
 
-  connect(buttonClearFile, SIGNAL(pressed()), this, SLOT(slotClearFile()));
-  connect(buttonClearClass, SIGNAL(pressed()), this, SLOT(slotClearClass()));
-  connect(buttonClearFunction, SIGNAL(pressed()), this, SLOT(slotClearFunction()));
+  connect(buttonClearFile, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotClearFile()));
+  connect(buttonClearClass, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotClearClass()));
+  connect(buttonClearFunction, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotClearFunction()));
 
   slotExpressionChanged();
 }
@@ -56,7 +56,7 @@ ConditionalBreakpointDialog::~ConditionalBreakpointDialog()
 void ConditionalBreakpointDialog::slotExpressionChanged()
 {
 
-  if(comboExpression->currentText().find( QRegExp("[^=!]=[^=]"), 0 ) >= 0)
+  if(comboExpression->currentText().find( TQRegExp("[^=!]=[^=]"), 0 ) >= 0)
     ledWarning->on();
   else
     ledWarning->off();
diff --git a/quanta/components/debugger/conditionalbreakpointdialog.h b/quanta/components/debugger/conditionalbreakpointdialog.h
index fdae39a3..cad4adeb 100644
--- a/quanta/components/debugger/conditionalbreakpointdialog.h
+++ b/quanta/components/debugger/conditionalbreakpointdialog.h
@@ -31,13 +31,13 @@ class ConditionalBreakpointDialog : public ConditionalBreakpointDialogS
       OnChange
     };
   
-    ConditionalBreakpointDialog(const QString& expression, const QString& inFile, const QString& inClass, const QString& inFunction);
+    ConditionalBreakpointDialog(const TQString& expression, const TQString& inFile, const TQString& inClass, const TQString& inFunction);
     ~ConditionalBreakpointDialog();
 
-//     QString expression();
-//     QString inFile();
-//     QString inClass();
-//     QString inFunction();
+//     TQString expression();
+//     TQString inFile();
+//     TQString inClass();
+//     TQString inFunction();
 //     DebuggerBreakpoint::Types type();
     
     DebuggerBreakpoint *breakpoint();
diff --git a/quanta/components/debugger/dbgp/dbgpnetwork.cpp b/quanta/components/debugger/dbgp/dbgpnetwork.cpp
index 8ef82c2d..62b0daa0 100644
--- a/quanta/components/debugger/dbgp/dbgpnetwork.cpp
+++ b/quanta/components/debugger/dbgp/dbgpnetwork.cpp
@@ -25,7 +25,7 @@
 #include <klocale.h>
 
 DBGpNetwork::DBGpNetwork()
-: QObject()
+: TQObject()
 {
   m_socket = NULL;
   m_server = NULL;
@@ -37,7 +37,7 @@ DBGpNetwork::~DBGpNetwork()
 {
 }
 
-void DBGpNetwork::sessionStart(bool useproxy, const QString& server, const QString & service)
+void DBGpNetwork::sessionStart(bool useproxy, const TQString& server, const TQString & service)
 {
 
   kdDebug(24002) << k_funcinfo << ", m_server: " << m_server << ", m_socket" << m_socket << endl;
@@ -48,11 +48,11 @@ void DBGpNetwork::sessionStart(bool useproxy, const QString& server, const QStri
     if(m_socket)
     {
 //       m_socket->setBufferSize(-1);
-      connect(m_socket, SIGNAL(gotError(int)), this, SLOT(slotError(int)));
-      connect(m_socket, SIGNAL(connected(const KResolverEntry &)), this, SLOT(slotConnected(const KNetwork::KResolverEntry &)));
-      connect(m_socket, SIGNAL(closed()), this, SLOT(slotConnectionClosed()));
-      connect(m_socket, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
-      connect(m_socket, SIGNAL(destroyed()), this, SLOT(slotSocketDestroyed()));
+      connect(m_socket, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotError(int)));
+      connect(m_socket, TQT_SIGNAL(connected(const KResolverEntry &)), this, TQT_SLOT(slotConnected(const KNetwork::KResolverEntry &)));
+      connect(m_socket, TQT_SIGNAL(closed()), this, TQT_SLOT(slotConnectionClosed()));
+      connect(m_socket, TQT_SIGNAL(readyRead()), this, TQT_SLOT(slotReadyRead()));
+      connect(m_socket, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotSocketDestroyed()));
       m_socket->connect();
       emit active(false);
       kdDebug(24002) << k_funcinfo << ", proxy:" << server << ", " << service << endl;
@@ -65,8 +65,8 @@ void DBGpNetwork::sessionStart(bool useproxy, const QString& server, const QStri
       m_server = new KNetwork::KServerSocket(service);
 
       m_server->setAddressReuseable(true);
-      connect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
-      connect(m_server, SIGNAL(gotError(int)), this, SLOT(slotError(int)));
+      connect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
+      connect(m_server, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotError(int)));
 
       if(m_server->listen())
       {
@@ -91,7 +91,7 @@ void DBGpNetwork::sessionEnd()
   if(m_socket)
   {
     m_socket->flush();
-    disconnect(m_socket, SIGNAL(closed()), this, SLOT(slotConnectionClosed()));
+    disconnect(m_socket, TQT_SIGNAL(closed()), this, TQT_SLOT(slotConnectionClosed()));
     if (m_socket)
       m_socket->close();
     delete m_socket;
@@ -146,7 +146,7 @@ void DBGpNetwork::slotReadyAccept()
   kdDebug(24002) << k_funcinfo << ", m_server: " << m_server << ", m_socket" << m_socket << endl;
   if(!m_socket)
   {
-    disconnect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
+    disconnect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
 
     m_socket = (KNetwork::KStreamSocket *)m_server->accept(); // KSocketServer returns a KStreamSocket (!)
     if(m_socket)
@@ -156,10 +156,10 @@ void DBGpNetwork::slotReadyAccept()
       m_socket->setAddressReuseable(true);
 //       m_socket->setSocketFlags(KExtendedSocket::inetSocket |  KExtendedSocket::inputBufferedSocket);
 //       m_socket->setBufferSize(-1);
-      connect(m_socket, SIGNAL(gotError(int)), this, SLOT(slotError(int)));
-      connect(m_socket, SIGNAL(connected(const KResolverEntry &)), this, SLOT(slotConnected(const KResolverEntry &)));
-      connect(m_socket, SIGNAL(closed()), this, SLOT(slotConnectionClosed()));
-      connect(m_socket, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
+      connect(m_socket, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotError(int)));
+      connect(m_socket, TQT_SIGNAL(connected(const KResolverEntry &)), this, TQT_SLOT(slotConnected(const KResolverEntry &)));
+      connect(m_socket, TQT_SIGNAL(closed()), this, TQT_SLOT(slotConnectionClosed()));
+      connect(m_socket, TQT_SIGNAL(readyRead()), this, TQT_SLOT(slotReadyRead()));
       connected();
     }
     else
@@ -215,7 +215,7 @@ void DBGpNetwork::slotConnectionClosed()
   }
 
   if(m_server)
-    connect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
+    connect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
 
   // Disable all session related actions and enable connection action
   emit connected(false);
@@ -242,7 +242,7 @@ void DBGpNetwork::slotReadyRead()
   while(m_socket && (m_socket->bytesAvailable() > 0 || m_fifo.length() >= (unsigned long)m_datalen))
   {
     int bytes;
-    QString data;
+    TQString data;
 
     if(m_socket && m_socket->bytesAvailable() > 0 )
     {
@@ -282,18 +282,18 @@ void DBGpNetwork::slotReadyRead()
   }
 }
 
-long DBGpNetwork::sendCommand(const QString & command)
+long DBGpNetwork::sendCommand(const TQString & command)
 {
   return sendCommand(command, "");
 }
 
-long DBGpNetwork::sendCommand(const QString & command, const QString & arguments)
+long DBGpNetwork::sendCommand(const TQString & command, const TQString & arguments)
 {
   if(!isConnected())
     return false;
 
   m_transaction_id++;
-  QString commandline = command + QString(" -i %1").arg(m_transaction_id) + (!arguments.isEmpty() ? " " : "") + arguments;
+  TQString commandline = command + TQString(" -i %1").arg(m_transaction_id) + (!arguments.isEmpty() ? " " : "") + arguments;
 
   kdDebug(24002) << k_funcinfo << ", sending: " << commandline << endl;
 
@@ -302,7 +302,7 @@ long DBGpNetwork::sendCommand(const QString & command, const QString & arguments
   return m_transaction_id;
 }
 
-long DBGpNetwork::sendCommand( const QString & command, const QString & arguments, const QString & data )
+long DBGpNetwork::sendCommand( const TQString & command, const TQString & arguments, const TQString & data )
 {
   QByteArrayFifo buffer;
   buffer.append(data.ascii(), data.length());
diff --git a/quanta/components/debugger/dbgp/dbgpnetwork.h b/quanta/components/debugger/dbgp/dbgpnetwork.h
index 435dbc8e..96faca06 100644
--- a/quanta/components/debugger/dbgp/dbgpnetwork.h
+++ b/quanta/components/debugger/dbgp/dbgpnetwork.h
@@ -45,22 +45,22 @@ class DBGpNetwork : public QObject
    signals:
     void active(bool isOnline);
     void connected(bool isConnected);
-    void networkError(const QString &error, bool log);
-    void command(const QString& data);
+    void networkError(const TQString &error, bool log);
+    void command(const TQString& data);
 
   public:
     DBGpNetwork();
     ~DBGpNetwork();
 
-    virtual void sessionStart(bool useproxy, const QString& server, const QString & service);
+    virtual void sessionStart(bool useproxy, const TQString& server, const TQString & service);
     virtual void sessionEnd();
 
     bool isConnected();
     bool isActive();
 
-    long sendCommand(const QString & command);
-    long sendCommand(const QString & command, const QString & arguments);
-    long sendCommand(const QString & command, const QString & arguments, const QString & data);
+    long sendCommand(const TQString & command);
+    long sendCommand(const TQString & command, const TQString & arguments);
+    long sendCommand(const TQString & command, const TQString & arguments, const TQString & data);
 
   public slots:
     // Socket slots
diff --git a/quanta/components/debugger/dbgp/dbgpsettings.cpp b/quanta/components/debugger/dbgp/dbgpsettings.cpp
index 80b7eaf1..e9bbc249 100644
--- a/quanta/components/debugger/dbgp/dbgpsettings.cpp
+++ b/quanta/components/debugger/dbgp/dbgpsettings.cpp
@@ -15,16 +15,16 @@
  ***************************************************************************/
 
 
-#include "qlineedit.h"
-#include "qcheckbox.h"
+#include "tqlineedit.h"
+#include "tqcheckbox.h"
 #include "dbgpsettings.h"
 #include <ktextbrowser.h>
 
-DBGpSettings::DBGpSettings(const QString &protocolversion)
+DBGpSettings::DBGpSettings(const TQString &protocolversion)
     : DBGpSettingsS(0, "DBGpSettings", false, 0)
 {
   textAbout->setText(textAbout->text().replace("%PROTOCOLVERSION%", protocolversion));
-  connect(checkLocalProject, SIGNAL(toggled(bool)), this, SLOT(slotLocalProjectToggle(bool)));
+  connect(checkLocalProject, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(slotLocalProjectToggle(bool)));
 }
 
 DBGpSettings::~DBGpSettings()
diff --git a/quanta/components/debugger/dbgp/dbgpsettings.h b/quanta/components/debugger/dbgp/dbgpsettings.h
index 4f2721ff..bdf8c2f0 100644
--- a/quanta/components/debugger/dbgp/dbgpsettings.h
+++ b/quanta/components/debugger/dbgp/dbgpsettings.h
@@ -24,7 +24,7 @@ class DBGpSettings : public DBGpSettingsS
     Q_OBJECT
 
   public:
-    DBGpSettings(const QString &protocolversion);
+    DBGpSettings(const TQString &protocolversion);
     ~DBGpSettings();
 
   public slots:
diff --git a/quanta/components/debugger/dbgp/qbytearrayfifo.cpp b/quanta/components/debugger/dbgp/qbytearrayfifo.cpp
index f8f14aab..4f8e72d8 100644
--- a/quanta/components/debugger/dbgp/qbytearrayfifo.cpp
+++ b/quanta/components/debugger/dbgp/qbytearrayfifo.cpp
@@ -18,7 +18,7 @@
  */
 
 #include "qbytearrayfifo.h"
-#include <qcstring.h>
+#include <tqcstring.h>
 #include <kmdcodec.h>
 
 QByteArrayFifo::QByteArrayFifo( )
@@ -27,10 +27,10 @@ QByteArrayFifo::QByteArrayFifo( )
   m_array.resize(0);
 }
 
-QString QByteArrayFifo::retrieve( )
+TQString QByteArrayFifo::retrieve( )
 {
   // See if there's a null teminator somewhere
-  QString str(m_array);
+  TQString str(m_array);
   size_t size = str.length() + 1;
 
   // Decrease size and move bytes to the beginning of the array
@@ -69,7 +69,7 @@ long QByteArrayFifo::find( char character )
   return m_array.find(character);
 }
 
-QString QByteArrayFifo::base64Encoded()
+TQString QByteArrayFifo::base64Encoded()
 {
   return KCodecs::base64Encode(m_array);
 }
diff --git a/quanta/components/debugger/dbgp/qbytearrayfifo.h b/quanta/components/debugger/dbgp/qbytearrayfifo.h
index 04dc4b2f..851c7f34 100644
--- a/quanta/components/debugger/dbgp/qbytearrayfifo.h
+++ b/quanta/components/debugger/dbgp/qbytearrayfifo.h
@@ -20,8 +20,8 @@
 #ifndef qbytearrayfifo_H
 #define qbytearrayfifo_H
 
-#include <qstring.h>
-#include <qcstring.h>
+#include <tqstring.h>
+#include <tqcstring.h>
 
 class QByteArrayFifo
 {
@@ -29,13 +29,13 @@ class QByteArrayFifo
   public:
     QByteArrayFifo();
     bool append(const char * chars, size_t size);
-    QString retrieve();
-    QString base64Encoded();
+    TQString retrieve();
+    TQString base64Encoded();
     long find(char character);
     size_t length() { return m_size; }
 
   private:
-    QByteArray m_array;
+    TQByteArray m_array;
     size_t m_size;
 
 };
diff --git a/quanta/components/debugger/dbgp/quantadebuggerdbgp.cpp b/quanta/components/debugger/dbgp/quantadebuggerdbgp.cpp
index 100ec9d3..d16319a9 100644
--- a/quanta/components/debugger/dbgp/quantadebuggerdbgp.cpp
+++ b/quanta/components/debugger/dbgp/quantadebuggerdbgp.cpp
@@ -22,14 +22,14 @@
 #include <kmdcodec.h>
 #include <kmessagebox.h>
 #include <krun.h>
-#include <qcheckbox.h>
-#include <qcombobox.h>
-#include <qfile.h>
-#include <qlineedit.h>
-#include <qmap.h>
-#include <qregexp.h>
-#include <qslider.h>
-#include <qstring.h>
+#include <tqcheckbox.h>
+#include <tqcombobox.h>
+#include <tqfile.h>
+#include <tqlineedit.h>
+#include <tqmap.h>
+#include <tqregexp.h>
+#include <tqslider.h>
+#include <tqstring.h>
 
 #include <stdarg.h>
 
@@ -49,7 +49,7 @@ K_EXPORT_COMPONENT_FACTORY( quantadebuggerdbgp,
 
 const char QuantaDebuggerDBGp::protocolversion[] = "1.0";
 
-QuantaDebuggerDBGp::QuantaDebuggerDBGp (QObject *parent, const char*, const QStringList&)
+QuantaDebuggerDBGp::QuantaDebuggerDBGp (TQObject *parent, const char*, const TQStringList&)
     : DebuggerClient (parent, "DBGp")
 {
   // Create a socket object and set up its signals
@@ -59,10 +59,10 @@ QuantaDebuggerDBGp::QuantaDebuggerDBGp (QObject *parent, const char*, const QStr
   setExecutionState(m_defaultExecutionState);
   emit updateStatus(DebuggerUI::NoSession);
   
-  connect(&m_network, SIGNAL(command(const QString&)), this, SLOT(processCommand(const QString&)));
-  connect(&m_network, SIGNAL(active(bool)), this, SLOT(slotNetworkActive(bool)));
-  connect(&m_network, SIGNAL(connected(bool)), this, SLOT(slotNetworkConnected(bool)));
-  connect(&m_network, SIGNAL(networkError(const QString &, bool)), this, SLOT(slotNetworkError(const QString &, bool)));
+  connect(&m_network, TQT_SIGNAL(command(const TQString&)), this, TQT_SLOT(processCommand(const TQString&)));
+  connect(&m_network, TQT_SIGNAL(active(bool)), this, TQT_SLOT(slotNetworkActive(bool)));
+  connect(&m_network, TQT_SIGNAL(connected(bool)), this, TQT_SLOT(slotNetworkConnected(bool)));
+  connect(&m_network, TQT_SIGNAL(networkError(const TQString &, bool)), this, TQT_SLOT(slotNetworkError(const TQString &, bool)));
 
 }
 
@@ -124,7 +124,7 @@ void QuantaDebuggerDBGp::slotNetworkConnected(bool connected)
 
 }
 
-void QuantaDebuggerDBGp::slotNetworkError(const QString &errormsg, bool log)
+void QuantaDebuggerDBGp::slotNetworkError(const TQString &errormsg, bool log)
 {
   debuggerInterface()->showStatus(errormsg, log);
 }
@@ -187,7 +187,7 @@ void QuantaDebuggerDBGp::setExecutionState( const State & state, bool forcesend
 }
 
 // Change executionstate of the script
-void QuantaDebuggerDBGp::setExecutionState(const QString &state)
+void QuantaDebuggerDBGp::setExecutionState(const TQString &state)
 {
   kdDebug(24002) << k_funcinfo << state << endl;
   
@@ -249,19 +249,19 @@ const uint QuantaDebuggerDBGp::supports(DebuggerClientCapabilities::Capabilities
 
 
 // Process a dbgp command
-void QuantaDebuggerDBGp::processCommand(const QString& datas)
+void QuantaDebuggerDBGp::processCommand(const TQString& datas)
 {
   kdDebug(24002) << k_lineinfo << datas.left(50) << " (" << datas.length() << " bytes)" << endl;
 
-  QDomDocument data;
+  TQDomDocument data;
   data.setContent(datas);
   kdDebug(24002) << datas << endl;
 
   // Did we get a normal response?
   if(data.elementsByTagName("response").count() > 0)
   {
-    QDomNode response = data.elementsByTagName("response").item(0);
-    QString command = attribute(response, "command");
+    TQDomNode response = data.elementsByTagName("response").item(0);
+    TQString command = attribute(response, "command");
 
     // Status command
     if(command == "status")
@@ -321,7 +321,7 @@ void QuantaDebuggerDBGp::processCommand(const QString& datas)
   }
   else if(data.elementsByTagName("init").count() > 0)
   {
-    QDomNode init = data.elementsByTagName("init").item(0);
+    TQDomNode init = data.elementsByTagName("init").item(0);
     initiateSession(init);
     return;
   }
@@ -334,7 +334,7 @@ void QuantaDebuggerDBGp::processCommand(const QString& datas)
 
 }
 
-void QuantaDebuggerDBGp::initiateSession(const QDomNode& initpacket)
+void QuantaDebuggerDBGp::initiateSession(const TQDomNode& initpacket)
 {
   if(attribute(initpacket, "protocol_version") != protocolversion)
   {
@@ -347,7 +347,7 @@ void QuantaDebuggerDBGp::initiateSession(const QDomNode& initpacket)
     endSession();
     return;
   }
-  QString path = attribute(initpacket, "fileuri");
+  TQString path = attribute(initpacket, "fileuri");
   if (path.startsWith("file://"))
   {
     path.remove(0, 7);
@@ -369,22 +369,22 @@ void QuantaDebuggerDBGp::initiateSession(const QDomNode& initpacket)
   m_network.sendCommand("feature_get", "-n quanta_initialized");
 }
 
-void QuantaDebuggerDBGp::stackShow(const QDomNode&node)
+void QuantaDebuggerDBGp::stackShow(const TQDomNode&node)
 {
   bool foundlowlevel = false;
   BacktraceType type;
-  QString typestr;
+  TQString typestr;
   
   // Clear backtrace
   debuggerInterface()->backtraceClear();
 
   // Add new one
-  for(QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling())
+  for(TQDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling())
   {
     // Type isnt currently correct with xdebug
 //     type = (attribute(child, "type") == "file" ? File : Eval);
     typestr = attribute(child, "filename");
-    if(typestr.find(QRegExp(".*%28[0-9]+%29%20%3A%20eval")) >= 0)
+    if(typestr.find(TQRegExp(".*%28[0-9]+%29%20%3A%20eval")) >= 0)
       type = Eval;
     else
       type = File;
@@ -409,10 +409,10 @@ void QuantaDebuggerDBGp::stackShow(const QDomNode&node)
   
 }
 
-void QuantaDebuggerDBGp::checkSupport( const QDomNode & node )
+void QuantaDebuggerDBGp::checkSupport( const TQDomNode & node )
 {
-  QString feature = attribute(node, "feature_name");
-  QString data = node.nodeValue();
+  TQString feature = attribute(node, "feature_name");
+  TQString data = node.nodeValue();
   if(feature == "supports_async")
     m_supportsasync = data.toLong();
 
@@ -430,7 +430,7 @@ void QuantaDebuggerDBGp::checkSupport( const QDomNode & node )
 
 }
 
-QString QuantaDebuggerDBGp::attribute(const QDomNode&node, const QString &attribute)
+TQString QuantaDebuggerDBGp::attribute(const TQDomNode&node, const TQString &attribute)
 {
   return node.attributes().namedItem(attribute).nodeValue();
 }
@@ -448,12 +448,12 @@ void QuantaDebuggerDBGp::debuggingState(bool enable)
 
 void QuantaDebuggerDBGp::sendWatches()
 {
-  for(QValueList<QString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
+  for(TQValueList<TQString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
     m_network.sendCommand("property_get", "-n " + (*it));
 }
 
 // Return name of debugger
-QString QuantaDebuggerDBGp::getName()
+TQString QuantaDebuggerDBGp::getName()
 {
   return "DBGp";      // no i18n on the name
 }
@@ -462,7 +462,7 @@ QString QuantaDebuggerDBGp::getName()
 // Send HTTP Request
 void QuantaDebuggerDBGp::request()
 {
-  QString request;
+  TQString request;
   request = debuggerInterface()->activeFileParts(m_startsession);
 
   //if(request.startsWith(m_localBasedir, false))
@@ -525,7 +525,7 @@ void QuantaDebuggerDBGp::pause()
 // Add a breakpoint
 void QuantaDebuggerDBGp::addBreakpoint (DebuggerBreakpoint* breakpoint)
 {
-  QString type;
+  TQString type;
   if(breakpoint->type() == DebuggerBreakpoint::LineBreakpoint)
     type = "line";
   else if(breakpoint->type() == DebuggerBreakpoint::ConditionalTrue)
@@ -537,20 +537,20 @@ void QuantaDebuggerDBGp::addBreakpoint (DebuggerBreakpoint* breakpoint)
                         "breakpoint_set", 
                         "-t " + type +
                         " -f " + mapLocalPathToServer(breakpoint->filePath()) +
-                        " -n " + QString::number(breakpoint->line() + 1)
+                        " -n " + TQString::number(breakpoint->line() + 1)
                         , breakpoint->condition());
 
-  breakpoint->setKey(QString("id %1").arg(id));
+  breakpoint->setKey(TQString("id %1").arg(id));
 }
 
-void QuantaDebuggerDBGp::setBreakpointKey( const QDomNode & response )
+void QuantaDebuggerDBGp::setBreakpointKey( const TQDomNode & response )
 {
   long id;
 
   id = attribute(response, "transaction_id").toLong();
   if(id > 0)
   {
-    QString oldkey = QString("id %1").arg(id);
+    TQString oldkey = TQString("id %1").arg(id);
     DebuggerBreakpoint *bp = debuggerInterface()->findDebuggerBreakpoint(oldkey);
     if(bp)
       debuggerInterface()->updateBreakpointKey(*bp, attribute(response, "id"));
@@ -565,13 +565,13 @@ void QuantaDebuggerDBGp::removeBreakpoint(DebuggerBreakpoint* bp)
 }
 
 // A file was opened...
-void QuantaDebuggerDBGp::fileOpened(const QString&)
+void QuantaDebuggerDBGp::fileOpened(const TQString&)
 {
 //   sendCommand("reinitialize", 0);
 }
 
 // Watch a variable
-void QuantaDebuggerDBGp::addWatch(const QString & variable)
+void QuantaDebuggerDBGp::addWatch(const TQString & variable)
 {
   if(m_watchlist.find(variable) == m_watchlist.end())
     m_watchlist.append(variable);
@@ -602,10 +602,10 @@ void QuantaDebuggerDBGp::showCondition(const StringMap &)
 }
 
 // Read configuration
-void QuantaDebuggerDBGp::readConfig(QDomNode node)
+void QuantaDebuggerDBGp::readConfig(TQDomNode node)
 {
   // Server
-  QDomNode valuenode = node.namedItem("serverhost");
+  TQDomNode valuenode = node.namedItem("serverhost");
   m_serverHost = valuenode.firstChild().nodeValue();
   if(m_serverHost.isEmpty())
     m_serverHost = "localhost";
@@ -670,7 +670,7 @@ void QuantaDebuggerDBGp::readConfig(QDomNode node)
 
 
 // Show configuration
-void QuantaDebuggerDBGp::showConfig(QDomNode node)
+void QuantaDebuggerDBGp::showConfig(TQDomNode node)
 {
   DBGpSettings set(protocolversion);
 
@@ -699,9 +699,9 @@ void QuantaDebuggerDBGp::showConfig(QDomNode node)
   if(m_profilerMapFilename)
     set.checkProfilerMapFilename->setChecked(true);
   
-  if(set.exec() == QDialog::Accepted )
+  if(set.exec() == TQDialog::Accepted )
   {
-    QDomElement el;
+    TQDomElement el;
 
     el = node.namedItem("localproject").toElement();
     if (!el.isNull())
@@ -785,7 +785,7 @@ void QuantaDebuggerDBGp::showConfig(QDomNode node)
                   + (set.checkBreakOnUserWarning->isChecked() ? QuantaDebuggerDBGp::User_Warning : 0)
                   + (set.checkBreakOnUserError->isChecked() ? QuantaDebuggerDBGp::User_Error : 0);
     kdDebug(24002) << k_funcinfo << ", m_errormask = " << m_errormask << endl;
-    el.appendChild( node.ownerDocument().createTextNode(QString::number(m_errormask)));
+    el.appendChild( node.ownerDocument().createTextNode(TQString::number(m_errormask)));
 
     // Profiler
     el = node.namedItem("profilerfilename").toElement();
@@ -815,14 +815,14 @@ void QuantaDebuggerDBGp::showConfig(QDomNode node)
 }
 
 // Map a server filepath to a local one using project settings
-QString QuantaDebuggerDBGp::mapServerPathToLocal(const QString& serverpath)
+TQString QuantaDebuggerDBGp::mapServerPathToLocal(const TQString& serverpath)
 {
   // Translate filename from server to local
   return debuggerInterface()->Mapper()->mapServerPathToLocal(serverpath);
 }
 
 // Map a local filepath to a server one using project settings
-QString QuantaDebuggerDBGp::mapLocalPathToServer(const QString& localpath)
+TQString QuantaDebuggerDBGp::mapLocalPathToServer(const TQString& localpath)
 {
   // Translate filename from local to server
   return debuggerInterface()->Mapper()->mapLocalPathToServer(localpath);
@@ -832,7 +832,7 @@ void QuantaDebuggerDBGp::variableSetValue(const DebuggerVariable &variable)
 {
   m_network.sendCommand("property_set", "-n " + variable.name(), variable.value());
 
-  for(QValueList<QString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
+  for(TQValueList<TQString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
     if((*it) == variable.name())
     {
       m_network.sendCommand("property_get", "-n " + variable.name(), variable.value());
@@ -849,14 +849,14 @@ void QuantaDebuggerDBGp::profilerOpen()
 
 void QuantaDebuggerDBGp::profilerOpen(bool forceopen)
 {
-  QString profileroutput = m_profilerFilename;
+  TQString profileroutput = m_profilerFilename;
   profileroutput.replace("%a", m_appid);
   profileroutput.replace("%c", m_initialscript);
 
   if(m_profilerMapFilename)
     profileroutput = mapServerPathToLocal( profileroutput);
  
-  bool exists = QFile::exists(profileroutput);
+  bool exists = TQFile::exists(profileroutput);
   if(m_profilerAutoOpen || forceopen)
   {
     if(exists)
@@ -878,7 +878,7 @@ void QuantaDebuggerDBGp::profilerOpen(bool forceopen)
   }
 }
 
-void QuantaDebuggerDBGp::typemapSetup( const QDomNode & typemapnode )
+void QuantaDebuggerDBGp::typemapSetup( const TQDomNode & typemapnode )
 {
   /*
     <map name="bool" type="bool" xsi:type="xsd:boolean"></map>
@@ -902,7 +902,7 @@ void QuantaDebuggerDBGp::typemapSetup( const QDomNode & typemapnode )
 //   m_variabletypes["object"] = "object"; 
 //   m_variabletypes["resource"] = "resource"; 
 
-  QDomNode child = typemapnode.firstChild();
+  TQDomNode child = typemapnode.firstChild();
   while(!child.isNull())
   {
     if(child.nodeName() == "map")
@@ -914,12 +914,12 @@ void QuantaDebuggerDBGp::typemapSetup( const QDomNode & typemapnode )
 }
 
 
-void QuantaDebuggerDBGp::showWatch( const QDomNode & variablenode)
+void QuantaDebuggerDBGp::showWatch( const TQDomNode & variablenode)
 {
   debuggerInterface()->showVariable(buildVariable(variablenode.firstChild()));
 }
 
-void QuantaDebuggerDBGp::propertySetResponse( const QDomNode & setnode)
+void QuantaDebuggerDBGp::propertySetResponse( const TQDomNode & setnode)
 {
   if(attribute(setnode, "success") == "0")
   {
@@ -928,7 +928,7 @@ void QuantaDebuggerDBGp::propertySetResponse( const QDomNode & setnode)
 }
 
 
-DebuggerVariable* QuantaDebuggerDBGp::buildVariable( const QDomNode & variablenode)
+DebuggerVariable* QuantaDebuggerDBGp::buildVariable( const TQDomNode & variablenode)
 {
   /*
     Sample:
@@ -946,44 +946,44 @@ DebuggerVariable* QuantaDebuggerDBGp::buildVariable( const QDomNode & variableno
       </property>
     </property>
   */
-  QString name = attribute(variablenode, "name");
-  QString type = m_variabletypes[attribute(variablenode, "type")];
+  TQString name = attribute(variablenode, "name");
+  TQString type = m_variabletypes[attribute(variablenode, "type")];
 
   if(type == "int")
   {
-    QString value = variablenode.firstChild().nodeValue();
+    TQString value = variablenode.firstChild().nodeValue();
     return debuggerInterface()->newDebuggerVariable( name, value, DebuggerVariableTypes::Integer);
   }
   else if (type == "string")
   {
-    QCString value = QCString(variablenode.firstChild().nodeValue());
+    TQCString value = TQCString(variablenode.firstChild().nodeValue());
     value = KCodecs::base64Decode(value);
     return debuggerInterface()->newDebuggerVariable( name, value, DebuggerVariableTypes::String);
   }
   else if (type == "bool")
   {
-    QString value = variablenode.firstChild().nodeValue();
+    TQString value = variablenode.firstChild().nodeValue();
     return debuggerInterface()->newDebuggerVariable( name, value, DebuggerVariableTypes::Boolean);
   }
   else if (type == "resource")
   {
-    QString value = variablenode.firstChild().nodeValue();
+    TQString value = variablenode.firstChild().nodeValue();
     return debuggerInterface()->newDebuggerVariable( name, value, DebuggerVariableTypes::Resource);
   }
   else if (type == "float")
   {
-    QString value = variablenode.firstChild().nodeValue();
+    TQString value = variablenode.firstChild().nodeValue();
     return debuggerInterface()->newDebuggerVariable( name, value, DebuggerVariableTypes::Float);
   }  
   else if (type == "null")
   {
-    QString value = variablenode.firstChild().nodeValue();
+    TQString value = variablenode.firstChild().nodeValue();
     return debuggerInterface()->newDebuggerVariable( name, "", DebuggerVariableTypes::Undefined);
   }
   else if (type == "hash" || type == "array" || type == "object")
   {
-    QDomNode child = variablenode.firstChild();
-    QPtrList<DebuggerVariable> vars ;
+    TQDomNode child = variablenode.firstChild();
+    TQPtrList<DebuggerVariable> vars ;
     while(!child.isNull())
     {
       DebuggerVariable* var = buildVariable( child);
@@ -1001,12 +1001,12 @@ DebuggerVariable* QuantaDebuggerDBGp::buildVariable( const QDomNode & variableno
   return debuggerInterface()->newDebuggerVariable(name, "", DebuggerVariableTypes::Error);;
 }
 
-void QuantaDebuggerDBGp::handleError(const QDomNode & statusnode )
+void QuantaDebuggerDBGp::handleError(const TQDomNode & statusnode )
 {
   
   if(attribute(statusnode, "reason") == "error" || attribute(statusnode, "reason") == "aborted")
   {
-    QDomNode errornode = statusnode.firstChild();
+    TQDomNode errornode = statusnode.firstChild();
     while(!errornode.isNull())
     {
       if(errornode.nodeName() == "error")
diff --git a/quanta/components/debugger/dbgp/quantadebuggerdbgp.h b/quanta/components/debugger/dbgp/quantadebuggerdbgp.h
index fd8eda22..7c9601ad 100644
--- a/quanta/components/debugger/dbgp/quantadebuggerdbgp.h
+++ b/quanta/components/debugger/dbgp/quantadebuggerdbgp.h
@@ -19,22 +19,22 @@
 
 #include <kserversocket.h>
 #include <kstreamsocket.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 #include <kurl.h>
-#include <qdom.h>
+#include <tqdom.h>
 
 #include "debuggerclient.h"
 #include "dbgpnetwork.h"
 
-typedef QValueList<QString> WatchList;
-typedef QMap<QString, QString> StringMap;
+typedef TQValueList<TQString> WatchList;
+typedef TQMap<TQString, TQString> StringMap;
 
 class QuantaDebuggerDBGp : public DebuggerClient
 {
     Q_OBJECT
 
   public:
-    QuantaDebuggerDBGp(QObject *parent, const char* name, const QStringList&);
+    QuantaDebuggerDBGp(TQObject *parent, const char* name, const TQStringList&);
     ~QuantaDebuggerDBGp();
 
     // Execution states
@@ -70,7 +70,7 @@ class QuantaDebuggerDBGp : public DebuggerClient
     void stepOut();
     void pause();
     void kill();
-    void setExecutionState(const QString &state);
+    void setExecutionState(const TQString &state);
     void setExecutionState(const State &state, bool forcesend = false);
 
     // Connection
@@ -78,17 +78,17 @@ class QuantaDebuggerDBGp : public DebuggerClient
     void endSession();
 
     // Return name of debugger
-    QString getName();
+    TQString getName();
 
     // Initiation
-    void checkSupport(const QDomNode&node);
+    void checkSupport(const TQDomNode&node);
 
     // New file opened in quanta
-    void fileOpened(const QString& file);
+    void fileOpened(const TQString& file);
 
     // Settings
-    void readConfig(QDomNode node);
-    void showConfig(QDomNode node);
+    void readConfig(TQDomNode node);
+    void showConfig(TQDomNode node);
 
     // Breakpoints
     void addBreakpoint(DebuggerBreakpoint* breakpoint);
@@ -96,26 +96,26 @@ class QuantaDebuggerDBGp : public DebuggerClient
     void showCondition(const StringMap &args);
 
     // Variables
-    void addWatch(const QString &variable);
+    void addWatch(const TQString &variable);
     void removeWatch(DebuggerVariable *var);
     void variableSetValue(const DebuggerVariable &variable);
-    void propertySetResponse( const QDomNode & setnode);
+    void propertySetResponse( const TQDomNode & setnode);
 
     // Call stack
-    void stackShow(const QDomNode&node);
+    void stackShow(const TQDomNode&node);
 
   private:
     DBGpNetwork m_network;
 
-    QString m_serverBasedir;
-    QString m_localBasedir;
-    QString m_serverPort;
-    QString m_serverHost;
-    QString m_startsession;
-    QString m_listenPort;
-    QString m_profilerFilename;
-    QString m_appid;
-    QString m_initialscript;
+    TQString m_serverBasedir;
+    TQString m_localBasedir;
+    TQString m_serverPort;
+    TQString m_serverHost;
+    TQString m_startsession;
+    TQString m_listenPort;
+    TQString m_profilerFilename;
+    TQString m_appid;
+    TQString m_initialscript;
     
     bool    m_useproxy;
     bool    m_profilerAutoOpen;
@@ -135,19 +135,19 @@ class QuantaDebuggerDBGp : public DebuggerClient
     void debuggingState(bool enable);
     void connected();
 
-    void handleError(const QDomNode & statusnode );
+    void handleError(const TQDomNode & statusnode );
         
-    QString mapServerPathToLocal(const QString& serverpath);
-    QString mapLocalPathToServer(const QString& localpath);
-    QString bpToDBGp(DebuggerBreakpoint* breakpoint);
-    void setBreakpointKey(const QDomNode& response);
+    TQString mapServerPathToLocal(const TQString& serverpath);
+    TQString mapLocalPathToServer(const TQString& localpath);
+    TQString bpToDBGp(DebuggerBreakpoint* breakpoint);
+    void setBreakpointKey(const TQDomNode& response);
 
-    QString attribute(const QDomNode&node, const QString &attribute);
-    void initiateSession(const QDomNode& initpacket);
+    TQString attribute(const TQDomNode&node, const TQString &attribute);
+    void initiateSession(const TQDomNode& initpacket);
 
-    void typemapSetup(const QDomNode& typemapnode);
-    void showWatch(const QDomNode& typemapnode);
-    DebuggerVariable* buildVariable(const QDomNode& typemapnode);
+    void typemapSetup(const TQDomNode& typemapnode);
+    void showWatch(const TQDomNode& typemapnode);
+    DebuggerVariable* buildVariable(const TQDomNode& typemapnode);
 
     // Profiler
     void profilerOpen(bool forceopen);
@@ -156,8 +156,8 @@ class QuantaDebuggerDBGp : public DebuggerClient
   public slots:
     void slotNetworkActive(bool active);
     void slotNetworkConnected(bool connected);
-    void slotNetworkError(const QString &errormsg, bool log);
-    void processCommand(const QString&);
+    void slotNetworkError(const TQString &errormsg, bool log);
+    void processCommand(const TQString&);
     
   signals:
     void updateStatus(DebuggerUI::DebuggerStatus);
diff --git a/quanta/components/debugger/debuggerbreakpoint.cpp b/quanta/components/debugger/debuggerbreakpoint.cpp
index ae8ed6cb..d19c299d 100644
--- a/quanta/components/debugger/debuggerbreakpoint.cpp
+++ b/quanta/components/debugger/debuggerbreakpoint.cpp
@@ -47,7 +47,7 @@ DebuggerBreakpoint::DebuggerBreakpoint( const DebuggerBreakpoint * bp )
 }
 
 
-DebuggerBreakpoint::DebuggerBreakpoint(const QString& filePath, int line)
+DebuggerBreakpoint::DebuggerBreakpoint(const TQString& filePath, int line)
 {
   m_filePath = filePath;
   m_line     = line;
@@ -56,8 +56,8 @@ DebuggerBreakpoint::DebuggerBreakpoint(const QString& filePath, int line)
 }
 
 DebuggerBreakpoint::DebuggerBreakpoint(const Types type,
-                                       const QString& conditionExpr, const QString& filePath, 
-                                       const QString& inClass, const QString& inFunction)
+                                       const TQString& conditionExpr, const TQString& filePath, 
+                                       const TQString& inClass, const TQString& inFunction)
 {
   m_conditionExpr = conditionExpr;
   m_filePath = filePath;
@@ -71,17 +71,17 @@ DebuggerBreakpoint::DebuggerBreakpoint(const Types type,
 DebuggerBreakpoint::~DebuggerBreakpoint()
 {}
 
-void DebuggerBreakpoint::setFilePath(const QString& filePath)
+void DebuggerBreakpoint::setFilePath(const TQString& filePath)
 {
   m_filePath = filePath;
 }
 
-void DebuggerBreakpoint::setClass(const QString& newclass)
+void DebuggerBreakpoint::setClass(const TQString& newclass)
 {
   m_class = newclass;
 }
 
-void DebuggerBreakpoint::setFunction(const QString& function)
+void DebuggerBreakpoint::setFunction(const TQString& function)
 {
   m_function = function;
 }
@@ -91,12 +91,12 @@ void DebuggerBreakpoint::setLine(int line)
   m_line = line;
 }
 
-void DebuggerBreakpoint::setCondition(const QString& expression)
+void DebuggerBreakpoint::setCondition(const TQString& expression)
 {
   m_conditionExpr = expression;
 }
 
-void DebuggerBreakpoint::setValue(const QString& value)
+void DebuggerBreakpoint::setValue(const TQString& value)
 {
   m_value = value;
 }
@@ -111,31 +111,31 @@ void DebuggerBreakpoint::setType(DebuggerBreakpoint::Types type )
   m_type = type;
 }
 
-void DebuggerBreakpoint::setKey(const QString& value)
+void DebuggerBreakpoint::setKey(const TQString& value)
 {
   m_key = value;
 }
 
-const QString& DebuggerBreakpoint::key() const
+const TQString& DebuggerBreakpoint::key() const
 {
   return m_key;
 }
 
-const QString& DebuggerBreakpoint::filePath() const
+const TQString& DebuggerBreakpoint::filePath() const
 {
   return m_filePath;
 }
 
-const QString& DebuggerBreakpoint::value() const
+const TQString& DebuggerBreakpoint::value() const
 {
   return m_value;
 }
 
-const QString& DebuggerBreakpoint::inClass() const
+const TQString& DebuggerBreakpoint::inClass() const
 {
   return m_class;
 }
-const QString& DebuggerBreakpoint::inFunction() const
+const TQString& DebuggerBreakpoint::inFunction() const
 {
   return m_function;
 }
@@ -150,7 +150,7 @@ int DebuggerBreakpoint::line() const
   return m_line;
 }
 
-const QString& DebuggerBreakpoint::condition() const
+const TQString& DebuggerBreakpoint::condition() const
 {
   return m_conditionExpr;
 }
diff --git a/quanta/components/debugger/debuggerbreakpoint.h b/quanta/components/debugger/debuggerbreakpoint.h
index 46e0950d..2be6c4f8 100644
--- a/quanta/components/debugger/debuggerbreakpoint.h
+++ b/quanta/components/debugger/debuggerbreakpoint.h
@@ -17,7 +17,7 @@
 
 #ifndef DEBUGGERBREAKPOINT_H
 #define DEBUGGERBREAKPOINT_H
-#include <qstring.h>
+#include <tqstring.h>
 
 
 class DebuggerBreakpoint
@@ -41,45 +41,45 @@ class DebuggerBreakpoint
     DebuggerBreakpoint();
     DebuggerBreakpoint(const DebuggerBreakpoint& bp);
     DebuggerBreakpoint(const DebuggerBreakpoint* bp);
-    DebuggerBreakpoint(const QString& filePath, int line); // Line BP
+    DebuggerBreakpoint(const TQString& filePath, int line); // Line BP
     DebuggerBreakpoint(const DebuggerBreakpoint::Types type,                   // Any kind
-                       const QString& conditionExpr, const QString& filePath = "", 
-                       const QString& inClass = "", const QString& inFunction = "");
+                       const TQString& conditionExpr, const TQString& filePath = "", 
+                       const TQString& inClass = "", const TQString& inFunction = "");
 
     virtual ~DebuggerBreakpoint();
 
-    virtual void setFunction(const QString& filePath);
-    virtual void setClass(const QString& filePath);
-    virtual void setFilePath(const QString& filePath);
+    virtual void setFunction(const TQString& filePath);
+    virtual void setClass(const TQString& filePath);
+    virtual void setFilePath(const TQString& filePath);
     virtual void setLine(int line);
-    virtual void setCondition(const QString& expression);
+    virtual void setCondition(const TQString& expression);
     virtual void setState(int state);
     virtual void setType(Types type);
-    virtual void setValue(const QString& value);
-    virtual void setKey(const QString& value);
+    virtual void setValue(const TQString& value);
+    virtual void setKey(const TQString& value);
 
-    virtual const QString& filePath() const;
-    virtual const QString& inClass() const;
-    virtual const QString& inFunction() const;
+    virtual const TQString& filePath() const;
+    virtual const TQString& inClass() const;
+    virtual const TQString& inFunction() const;
     virtual int line() const;
-    virtual const QString& condition() const;
+    virtual const TQString& condition() const;
     virtual int state() const;
     virtual DebuggerBreakpoint::Types type() const;
-    virtual const QString& value() const;
-    virtual const QString& key() const;
+    virtual const TQString& value() const;
+    virtual const TQString& key() const;
 
     bool operator == (DebuggerBreakpoint) const;
 
   protected:
-    QString m_filePath;
-    QString m_class;
-    QString m_function;
+    TQString m_filePath;
+    TQString m_class;
+    TQString m_function;
     int     m_line;
-    QString m_conditionExpr;
+    TQString m_conditionExpr;
     int     m_state;
     Types   m_type;
-    QString m_value;
-    QString m_key;
+    TQString m_value;
+    TQString m_key;
 };
 
 #endif
diff --git a/quanta/components/debugger/debuggerbreakpointlist.cpp b/quanta/components/debugger/debuggerbreakpointlist.cpp
index ba117965..6a47d296 100644
--- a/quanta/components/debugger/debuggerbreakpointlist.cpp
+++ b/quanta/components/debugger/debuggerbreakpointlist.cpp
@@ -15,7 +15,7 @@
  *                                                                          *
  ***************************************************************************/
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <ktexteditor/markinterfaceextension.h>
 #include <kdebug.h>
 
@@ -76,7 +76,7 @@ void DebuggerBreakpointList::remove(DebuggerBreakpoint* bp)
 
 
 
-DebuggerBreakpoint* DebuggerBreakpointList::retrieve(const QString& filePath, int line)
+DebuggerBreakpoint* DebuggerBreakpointList::retrieve(const TQString& filePath, int line)
 {
   BreakpointList_t::iterator it;
 
@@ -162,7 +162,7 @@ DebuggerBreakpoint* DebuggerBreakpointList::next()
   }
 }
 
-DebuggerBreakpoint * DebuggerBreakpointList::findDebuggerBreakpoint( const QString & key )
+DebuggerBreakpoint * DebuggerBreakpointList::findDebuggerBreakpoint( const TQString & key )
 {
   BreakpointList_t::iterator it;
   for(it = m_breakpointList->begin(); it != m_breakpointList->end(); ++it)
@@ -176,7 +176,7 @@ DebuggerBreakpoint * DebuggerBreakpointList::findDebuggerBreakpoint( const QStri
   return NULL;
 }
 
-void DebuggerBreakpointList::updateBreakpointKey( const DebuggerBreakpoint & bp, const QString & newkey )
+void DebuggerBreakpointList::updateBreakpointKey( const DebuggerBreakpoint & bp, const TQString & newkey )
 {
   //DebuggerBreakpoint *bpp = new DebuggerBreakpoint(bp);
   BreakpointList_t::iterator it;
diff --git a/quanta/components/debugger/debuggerbreakpointlist.h b/quanta/components/debugger/debuggerbreakpointlist.h
index 4ca26a95..aa6cd803 100644
--- a/quanta/components/debugger/debuggerbreakpointlist.h
+++ b/quanta/components/debugger/debuggerbreakpointlist.h
@@ -18,12 +18,12 @@
 #ifndef DEBUGGERBREAKPOINTLIST_H
 #define DEBUGGERBREAKPOINTLIST_H
 
-#include <qobject.h>
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqobject.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 class DebuggerBreakpoint;
-    typedef QValueList<DebuggerBreakpoint*> BreakpointList_t;
+    typedef TQValueList<DebuggerBreakpoint*> BreakpointList_t;
 
 class DebuggerBreakpointList
 {
@@ -39,15 +39,15 @@ class DebuggerBreakpointList
 
     void add(DebuggerBreakpoint*);
     void remove(DebuggerBreakpoint*);
-    //int remove(QString filePath, int line);
+    //int remove(TQString filePath, int line);
     void clear();
     bool exists(DebuggerBreakpoint*);
-    //bool exists(QString filePath, int line);
+    //bool exists(TQString filePath, int line);
 
-    DebuggerBreakpoint* retrieve(const QString& filePath, int line);
+    DebuggerBreakpoint* retrieve(const TQString& filePath, int line);
 
-    DebuggerBreakpoint * findDebuggerBreakpoint(const QString& key);
-    void updateBreakpointKey(const DebuggerBreakpoint &bp, const QString& newkey);
+    DebuggerBreakpoint * findDebuggerBreakpoint(const TQString& key);
+    void updateBreakpointKey(const DebuggerBreakpoint &bp, const TQString& newkey);
 
     size_t count();
     void rewind();
diff --git a/quanta/components/debugger/debuggerbreakpointview.cpp b/quanta/components/debugger/debuggerbreakpointview.cpp
index 2f7eea36..8614bc28 100644
--- a/quanta/components/debugger/debuggerbreakpointview.cpp
+++ b/quanta/components/debugger/debuggerbreakpointview.cpp
@@ -52,7 +52,7 @@ DebuggerBreakpointViewItem::DebuggerBreakpointViewItem(DebuggerBreakpointView* v
 }
 
 
-DebuggerBreakpointView::DebuggerBreakpointView(QWidget *parent, const char *name)
+DebuggerBreakpointView::DebuggerBreakpointView(TQWidget *parent, const char *name)
     : KListView(parent, name)
 {
   // If you change here, change the DebuggerBreakpointViewColumns enums above
@@ -63,16 +63,16 @@ DebuggerBreakpointView::DebuggerBreakpointView(QWidget *parent, const char *name
   addColumn(i18n("Line"));
   addColumn(i18n("Value"));
 
-  setResizeMode(QListView::AllColumns);
+  setResizeMode(TQListView::AllColumns);
   setAllColumnsShowFocus(true);
 
   m_breakpointPopup = new KPopupMenu(this);
-  m_breakpointPopup->insertItem(SmallIcon("editdelete"), i18n("&Remove"), this, SLOT(slotRemoveSelected()));
+  m_breakpointPopup->insertItem(SmallIcon("editdelete"), i18n("&Remove"), this, TQT_SLOT(slotRemoveSelected()));
 
-  connect(this, SIGNAL( contextMenu( KListView *, QListViewItem *, const QPoint & ) ), this, SLOT(slotBreakpointContextMenu(KListView *, QListViewItem *, const QPoint &)));
+  connect(this, TQT_SIGNAL( contextMenu( KListView *, TQListViewItem *, const TQPoint & ) ), this, TQT_SLOT(slotBreakpointContextMenu(KListView *, TQListViewItem *, const TQPoint &)));
 
   // Jump to bp
-  connect(this, SIGNAL( doubleClicked( QListViewItem *, const QPoint &, int) ), this, SLOT(slotBreakpointDoubleClick( QListViewItem *, const QPoint &, int)));
+  connect(this, TQT_SIGNAL( doubleClicked( TQListViewItem *, const TQPoint &, int) ), this, TQT_SLOT(slotBreakpointDoubleClick( TQListViewItem *, const TQPoint &, int)));
 }
 
 
@@ -81,7 +81,7 @@ DebuggerBreakpointView::~DebuggerBreakpointView()
 
 void DebuggerBreakpointView::deleteBreakpoint(const DebuggerBreakpoint &bp)
 {
-  QListViewItem *item = findBreakpoint(bp, false);
+  TQListViewItem *item = findBreakpoint(bp, false);
   if(item)
   {
     delete item;
@@ -91,14 +91,14 @@ void DebuggerBreakpointView::deleteBreakpoint(const DebuggerBreakpoint &bp)
 
 void DebuggerBreakpointView::showBreakpoint(const DebuggerBreakpoint &bp)
 {
-  QListViewItem *item = findBreakpoint(bp);
+  TQListViewItem *item = findBreakpoint(bp);
   if(!item)
     return;
 
   if(bp.type() == DebuggerBreakpoint::LineBreakpoint)
   {
     item->setText(DebuggerBreakpointViewColumns::Value, "");
-    item->setText(DebuggerBreakpointViewColumns::Line, QString::number(bp.line() + 1));
+    item->setText(DebuggerBreakpointViewColumns::Line, TQString::number(bp.line() + 1));
   }
   else
   {
@@ -111,7 +111,7 @@ void DebuggerBreakpointView::showBreakpoint(const DebuggerBreakpoint &bp)
   item->setText(DebuggerBreakpointViewColumns::Function, bp.inFunction());
 }
 
-QListViewItem* DebuggerBreakpointView::findBreakpoint(const DebuggerBreakpoint& bp, bool addIfNotExist)
+TQListViewItem* DebuggerBreakpointView::findBreakpoint(const DebuggerBreakpoint& bp, bool addIfNotExist)
 {
   // Find the old item if its there
   DebuggerBreakpointViewItem* item = dynamic_cast<DebuggerBreakpointViewItem*>(firstChild());
@@ -152,7 +152,7 @@ void DebuggerBreakpointView::slotRemoveSelected()
   emit removeBreakpoint(&bp);
 }
 
-void DebuggerBreakpointView::keyPressEvent(QKeyEvent *e)
+void DebuggerBreakpointView::keyPressEvent(TQKeyEvent *e)
 {
   if(e->key() != Qt::Key_Delete)
   {
@@ -168,7 +168,7 @@ void DebuggerBreakpointView::clear()
   KListView::clear();
 }
 
-void DebuggerBreakpointView::slotBreakpointDoubleClick(QListViewItem *item, const QPoint &, int )
+void DebuggerBreakpointView::slotBreakpointDoubleClick(TQListViewItem *item, const TQPoint &, int )
 {
   if(!item)
     return;
@@ -182,7 +182,7 @@ void DebuggerBreakpointView::slotBreakpointDoubleClick(QListViewItem *item, cons
 
 }
 
-void DebuggerBreakpointView::slotBreakpointContextMenu(KListView *, QListViewItem *, const QPoint& point)
+void DebuggerBreakpointView::slotBreakpointContextMenu(KListView *, TQListViewItem *, const TQPoint& point)
 {
   if(!selectedItem())
     return;
diff --git a/quanta/components/debugger/debuggerbreakpointview.h b/quanta/components/debugger/debuggerbreakpointview.h
index 1e3ca087..196cd451 100644
--- a/quanta/components/debugger/debuggerbreakpointview.h
+++ b/quanta/components/debugger/debuggerbreakpointview.h
@@ -21,7 +21,7 @@
 
 #include <klistview.h>
 #include <kpopupmenu.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 #include "debuggerbreakpoint.h"
 
 // class DebuggerBreakpoint;
@@ -46,7 +46,7 @@ class DebuggerBreakpointView : public KListView
   Q_OBJECT
 
   public:
-    DebuggerBreakpointView(QWidget *parent = 0, const char *name = 0);
+    DebuggerBreakpointView(TQWidget *parent = 0, const char *name = 0);
     ~DebuggerBreakpointView();
 
     void showBreakpoint(const DebuggerBreakpoint& bp);
@@ -58,15 +58,15 @@ class DebuggerBreakpointView : public KListView
 
   public slots:
     void slotRemoveSelected();
-    void slotBreakpointContextMenu(KListView *list, QListViewItem * item, const QPoint& point);
-    void slotBreakpointDoubleClick(QListViewItem *item, const QPoint &point, int column);
+    void slotBreakpointContextMenu(KListView *list, TQListViewItem * item, const TQPoint& point);
+    void slotBreakpointDoubleClick(TQListViewItem *item, const TQPoint &point, int column);
 
   signals:
     void removeBreakpoint(DebuggerBreakpoint*);
 
   private:
-    void keyPressEvent(QKeyEvent *e);
-    QListViewItem* findBreakpoint(const DebuggerBreakpoint& bp, bool addIfNotExist = true);
+    void keyPressEvent(TQKeyEvent *e);
+    TQListViewItem* findBreakpoint(const DebuggerBreakpoint& bp, bool addIfNotExist = true);
 
     KPopupMenu *m_breakpointPopup;
 };
diff --git a/quanta/components/debugger/debuggermanager.cpp b/quanta/components/debugger/debuggermanager.cpp
index bbc6336c..4c5aaa58 100644
--- a/quanta/components/debugger/debuggermanager.cpp
+++ b/quanta/components/debugger/debuggermanager.cpp
@@ -26,7 +26,7 @@
 #include <kmessagebox.h>
 #include <qextfileinfo.h>
 #include <kinputdialog.h>
-#include <qlineedit.h>
+#include <tqlineedit.h>
 
 #include "quanta.h"
 #include "document.h"
@@ -49,8 +49,8 @@
 // dialogs
 #include "debuggervariablesets.h"
 
-DebuggerManager::DebuggerManager(QObject *myparent)
-    : QObject(myparent)
+DebuggerManager::DebuggerManager(TQObject *myparent)
+    : TQObject(myparent)
 {
   initActions();
 
@@ -62,12 +62,12 @@ DebuggerManager::DebuggerManager(QObject *myparent)
   m_client = NULL;
 }
 
-void DebuggerManager::slotNewProjectLoaded(const QString &projectname, const KURL &, const KURL &)
+void DebuggerManager::slotNewProjectLoaded(const TQString &projectname, const KURL &, const KURL &)
 {
   if(m_client)
   {
     
-    disconnect(m_client, SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
+    disconnect(m_client, TQT_SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, TQT_SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
 
     delete m_client;
     m_client = NULL;
@@ -98,8 +98,8 @@ void DebuggerManager::slotNewProjectLoaded(const QString &projectname, const KUR
         int errCode = 0;
 //Workaround for dynamic_cast not working correctly on SUSE 10, gcc 4.0.2
 //The correct way should be a simple:
-// m_client = KParts::ComponentFactory::createInstanceFromService<DebuggerClient>(service, this, 0, QStringList(), &errCode);
-        QObject* obj = KParts::ComponentFactory::createInstanceFromService<QObject>(service, this, 0, QStringList(), &errCode);
+// m_client = KParts::ComponentFactory::createInstanceFromService<DebuggerClient>(service, this, 0, TQStringList(), &errCode);
+        TQObject* obj = KParts::ComponentFactory::createInstanceFromService<TQObject>(service, this, 0, TQStringList(), &errCode);
         if (obj && obj->inherits("DebuggerClient"))
           m_client = static_cast<DebuggerClient *>(obj);
 
@@ -118,10 +118,10 @@ void DebuggerManager::slotNewProjectLoaded(const QString &projectname, const KUR
   // Tell client to load its settings
   if (m_client)
   {
-    QDomNode nodeThisDbg;
-    QDomDocument *dom = Project::ref()->sessionDom();
-    QDomNode projectNode = dom->firstChild().firstChild();
-    QDomNode nodeDbg  = projectNode.namedItem("debuggers");
+    TQDomNode nodeThisDbg;
+    TQDomDocument *dom = Project::ref()->sessionDom();
+    TQDomNode projectNode = dom->firstChild().firstChild();
+    TQDomNode nodeDbg  = projectNode.namedItem("debuggers");
     if(nodeDbg.isNull())
     {
       nodeDbg = dom->createElement("debuggers");
@@ -143,15 +143,15 @@ void DebuggerManager::slotNewProjectLoaded(const QString &projectname, const KUR
 
     // recreate UI
     m_debuggerui = new DebuggerUI(this, "debuggerui");
-    connect(m_client, SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
+    connect(m_client, TQT_SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, TQT_SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
     
     // Load saved breakpoints
     if(Project::ref()->debuggerPersistentBreakpoints())
     {
-      QDomNode nodeBreakpoints = nodeDbg.namedItem("breakpoints");
+      TQDomNode nodeBreakpoints = nodeDbg.namedItem("breakpoints");
       if(!nodeBreakpoints.isNull())
       {
-        QDomNode child = nodeBreakpoints.firstChild();
+        TQDomNode child = nodeBreakpoints.firstChild();
         while(!child.isNull())
         {
           DebuggerBreakpoint* bp = new DebuggerBreakpoint();
@@ -180,13 +180,13 @@ void DebuggerManager::slotNewProjectLoaded(const QString &projectname, const KUR
     // Load saved Watches
     if(Project::ref()->debuggerPersistentWatches())
     {
-      QDomNode nodeWatches = nodeDbg.namedItem("watches");
+      TQDomNode nodeWatches = nodeDbg.namedItem("watches");
       if(!nodeWatches.isNull())
       {
-        QDomNode child = nodeWatches.firstChild();
+        TQDomNode child = nodeWatches.firstChild();
         while(!child.isNull())
         {
-          QString watch = child.attributes().namedItem("name").nodeValue();
+          TQString watch = child.attributes().namedItem("name").nodeValue();
           DebuggerVariable *var = new DebuggerVariable(watch, "", DebuggerVariableTypes::Undefined);
           m_debuggerui->addVariable(var);
           m_client->addWatch(watch);
@@ -212,65 +212,65 @@ void DebuggerManager::initActions()
     return;
 
   //Debugger, breakpoint
-  newaction = new KAction(i18n("Toggle &Breakpoint"), SmallIcon("debug_breakpoint"), Qt::CTRL+Qt::SHIFT+Qt::Key_B, this, SLOT(toggleBreakpoint()), ac, "debug_breakpoints_toggle");
+  newaction = new KAction(i18n("Toggle &Breakpoint"), SmallIcon("debug_breakpoint"), Qt::CTRL+Qt::SHIFT+Qt::Key_B, this, TQT_SLOT(toggleBreakpoint()), ac, "debug_breakpoints_toggle");
   newaction->setToolTip(i18n("Toggles a breakpoint at the current cursor location"));
   
-  newaction = new KAction(i18n("&Clear Breakpoints"), 0, this, SLOT(clearBreakpoints()), ac, "debug_breakpoints_clear");
+  newaction = new KAction(i18n("&Clear Breakpoints"), 0, this, TQT_SLOT(clearBreakpoints()), ac, "debug_breakpoints_clear");
   newaction->setToolTip(i18n("Clears all breakpoints"));
   
-  newaction = new KAction(i18n("Break When..."), SmallIcon("math_int"), 0, this, SLOT(slotConditionalBreakpoint()), ac, "debug_conditional_break");
+  newaction = new KAction(i18n("Break When..."), SmallIcon("math_int"), 0, this, TQT_SLOT(slotConditionalBreakpoint()), ac, "debug_conditional_break");
   newaction->setToolTip(i18n("Adds a new conditional breakpoint"));
   
-  newaction = new KAction(i18n("Break When..."), SmallIcon("math_int"), 0, this, SLOT(slotConditionalBreakpoint()), ac, "debug_conditional_breakdialog");
+  newaction = new KAction(i18n("Break When..."), SmallIcon("math_int"), 0, this, TQT_SLOT(slotConditionalBreakpoint()), ac, "debug_conditional_breakdialog");
   newaction->setToolTip(i18n("Adds a new conditional breakpoint"));
 
   // Execution
-  newaction = new KAction(i18n("Send HTTP R&equest"), SmallIcon("debug_currentline"), 0, this, SLOT(slotDebugRequest()), ac, "debug_request");
+  newaction = new KAction(i18n("Send HTTP R&equest"), SmallIcon("debug_currentline"), 0, this, TQT_SLOT(slotDebugRequest()), ac, "debug_request");
   newaction->setToolTip(i18n("Initiate HTTP Request to the server with debugging activated"));
   
-  newaction = new KAction(i18n("&Trace"), SmallIcon("debug_run"), 0, this, SLOT(slotDebugTrace()), ac, "debug_trace");
+  newaction = new KAction(i18n("&Trace"), SmallIcon("debug_run"), 0, this, TQT_SLOT(slotDebugTrace()), ac, "debug_trace");
   newaction->setToolTip(i18n("Traces through the script. If a script is currently not being debugged, it will start in trace mode when started"));
   
-  newaction = new KAction(i18n("&Run"), SmallIcon("debug_leap"), 0, this, SLOT(slotDebugRun()), ac, "debug_run");
+  newaction = new KAction(i18n("&Run"), SmallIcon("debug_leap"), 0, this, TQT_SLOT(slotDebugRun()), ac, "debug_run");
   newaction->setToolTip(i18n("Runs the script. If a script is currently not being debugged, it will start in run mode when started"));
   
-  newaction = new KAction(i18n("&Step"), SmallIcon("debug_stepover"), 0, this, SLOT(slotDebugStepOver()), ac, "debug_stepover");
+  newaction = new KAction(i18n("&Step"), SmallIcon("debug_stepover"), 0, this, TQT_SLOT(slotDebugStepOver()), ac, "debug_stepover");
   newaction->setToolTip(i18n("Executes the next line of execution, but does not step into functions or includes"));
   
-  newaction = new KAction(i18n("Step &Into"), SmallIcon("debug_stepinto"), 0, this, SLOT(slotDebugStepInto()), ac, "debug_stepinto");
+  newaction = new KAction(i18n("Step &Into"), SmallIcon("debug_stepinto"), 0, this, TQT_SLOT(slotDebugStepInto()), ac, "debug_stepinto");
   newaction->setToolTip(i18n("Executes the next line of execution and steps into it if it is a function call or inclusion of a file"));
   
-  newaction = new KAction(i18n("S&kip"), SmallIcon("debug_skip"), 0, this, SLOT(slotDebugSkip()), ac, "debug_skip");
+  newaction = new KAction(i18n("S&kip"), SmallIcon("debug_skip"), 0, this, TQT_SLOT(slotDebugSkip()), ac, "debug_skip");
   newaction->setToolTip(i18n("Skips the next command of execution and makes the next command the current one"));
   
-  newaction = new KAction(i18n("Step &Out"), SmallIcon("debug_stepout"), 0, this, SLOT(slotDebugStepOut()), ac, "debug_stepout");
+  newaction = new KAction(i18n("Step &Out"), SmallIcon("debug_stepout"), 0, this, TQT_SLOT(slotDebugStepOut()), ac, "debug_stepout");
   newaction->setToolTip(i18n("Executes the rest of the commands in the current function/file and pauses when it is done (when it reaches a higher level in the backtrace)"));
   
-  newaction = new KAction(i18n("&Pause"), SmallIcon("debug_pause"), 0, this, SLOT(slotDebugPause()), ac, "debug_pause");
+  newaction = new KAction(i18n("&Pause"), SmallIcon("debug_pause"), 0, this, TQT_SLOT(slotDebugPause()), ac, "debug_pause");
   newaction->setToolTip(i18n("Pauses the scripts if it is running or tracing. If a script is currently not being debugged, it will start in paused mode when started"));
-  newaction = new KAction(i18n("Kill"), SmallIcon("debug_kill"), 0, this, SLOT(slotDebugKill()), ac, "debug_kill");
+  newaction = new KAction(i18n("Kill"), SmallIcon("debug_kill"), 0, this, TQT_SLOT(slotDebugKill()), ac, "debug_kill");
   newaction->setToolTip(i18n("Kills the currently running script"));
   
-  newaction = new KAction(i18n("Start Session"), SmallIcon("debug_connect"), 0, this, SLOT(slotDebugStartSession()), ac, "debug_connect");
+  newaction = new KAction(i18n("Start Session"), SmallIcon("debug_connect"), 0, this, TQT_SLOT(slotDebugStartSession()), ac, "debug_connect");
   newaction->setToolTip(i18n("Starts the debugger internally (Makes debugging possible)"));
   
-  newaction = new KAction(i18n("End Session"), SmallIcon("debug_disconnect"), 0, this, SLOT(slotDebugEndSession()), ac, "debug_disconnect");
+  newaction = new KAction(i18n("End Session"), SmallIcon("debug_disconnect"), 0, this, TQT_SLOT(slotDebugEndSession()), ac, "debug_disconnect");
   newaction->setToolTip(i18n("Stops the debugger internally (debugging not longer possible)"));
 
   // Variables
-  newaction = new KAction(i18n("Watch Variable"), SmallIcon("math_brace"), 0, this, SLOT(slotAddWatch()), ac, "debug_addwatch");
+  newaction = new KAction(i18n("Watch Variable"), SmallIcon("math_brace"), 0, this, TQT_SLOT(slotAddWatch()), ac, "debug_addwatch");
   newaction->setToolTip(i18n("Adds a variable to the watch list"));
   
-  newaction = new KAction(i18n("Watch Variable"), SmallIcon("math_brace"), 0, this, SLOT(slotAddWatch()), ac, "debug_addwatchdialog");
+  newaction = new KAction(i18n("Watch Variable"), SmallIcon("math_brace"), 0, this, TQT_SLOT(slotAddWatch()), ac, "debug_addwatchdialog");
   newaction->setToolTip(i18n("Adds a variable to the watch list"));
   
-  newaction = new KAction(i18n("Set Value of Variable"), SmallIcon("edit"), 0, this, SLOT(slotVariableSet()), ac, "debug_variable_set");
+  newaction = new KAction(i18n("Set Value of Variable"), SmallIcon("edit"), 0, this, TQT_SLOT(slotVariableSet()), ac, "debug_variable_set");
   newaction->setToolTip(i18n("Changes the value of a variable"));
   
-  newaction = new KAction(i18n("Set Value of Variable"), SmallIcon("edit"), 0, this, SLOT(slotVariableSet()), ac, "debug_variable_setdialog");
+  newaction = new KAction(i18n("Set Value of Variable"), SmallIcon("edit"), 0, this, TQT_SLOT(slotVariableSet()), ac, "debug_variable_setdialog");
   newaction->setToolTip(i18n("Changes the value of a variable"));
 
-  newaction = new KAction(i18n("Open Profiler Output"), SmallIcon("launch"), 0, this, SLOT(slotProfilerOpen()), ac, "debug_profiler_open");
+  newaction = new KAction(i18n("Open Profiler Output"), SmallIcon("launch"), 0, this, TQT_SLOT(slotProfilerOpen()), ac, "debug_profiler_open");
   newaction->setToolTip(i18n("Opens the profiler output file"));
 
   enableAction("*", false);
@@ -299,7 +299,7 @@ DebuggerManager::~DebuggerManager()
   if(m_client)
   {
         
-    disconnect(m_client, SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
+    disconnect(m_client, TQT_SIGNAL(updateStatus(DebuggerUI::DebuggerStatus)), m_debuggerui, TQT_SLOT(slotStatus(DebuggerUI::DebuggerStatus)));
 
     delete m_client;
     m_client = 0L;
@@ -313,7 +313,7 @@ DebuggerManager::~DebuggerManager()
   m_pathmapper = 0L;
 }
 
-void DebuggerManager::enableAction(const QString& action, bool enable)
+void DebuggerManager::enableAction(const TQString& action, bool enable)
 {
   if(action == "*")
   {
@@ -372,7 +372,7 @@ void DebuggerManager::slotAddWatch()
     return;
 
 
-  QString watch = KInputDialog::getText(i18n("Add Watch"), i18n("Specify variable to watch:"), quantaApp->popupWord);
+  TQString watch = KInputDialog::getText(i18n("Add Watch"), i18n("Specify variable to watch:"), quantaApp->popupWord);
   quantaApp->popupWord = "";
   if(!watch.isEmpty())
   {
@@ -392,7 +392,7 @@ void DebuggerManager::slotVariableSet()
   DebuggerVariableSetS dlg;
   dlg.lineVariable->setText(quantaApp->popupWord);
   quantaApp->popupWord = "";
-  if(dlg.exec() == QDialog::Accepted)
+  if(dlg.exec() == TQDialog::Accepted)
   {
     DebuggerVariable var;
     var.setName(dlg.lineVariable->text());
@@ -403,7 +403,7 @@ void DebuggerManager::slotVariableSet()
 
 void DebuggerManager::slotConditionalBreakpoint()
 {
-  QString file;
+  TQString file;
   
   kdDebug(24002) << "DebuggerManager::slotConditionalBreakpoint() " << quantaApp->popupWord << endl;
   if(!m_client)
@@ -415,7 +415,7 @@ void DebuggerManager::slotConditionalBreakpoint()
 
   ConditionalBreakpointDialog dlg(quantaApp->popupWord, file, "", "");
   quantaApp->popupWord = "";
-  if(dlg.exec() == QDialog::Accepted)
+  if(dlg.exec() == TQDialog::Accepted)
   {
     DebuggerBreakpoint * bp = dlg.breakpoint();
     if(bp)
@@ -524,7 +524,7 @@ void DebuggerManager::slotProfilerOpen( )
 }
 
 // A new file was opened, tell the debugger so it can tell us about breakpoints etc
-void DebuggerManager::fileOpened(const QString& file)
+void DebuggerManager::fileOpened(const TQString& file)
 {
 
   // Set breakpoint markers if we have a bp in the file
@@ -569,13 +569,13 @@ void DebuggerManager::refreshBreakpoints()
 
 
 // The debug server told us we have a breakpoint, mark it in the file
-void DebuggerManager::haveBreakpoint (const QString& file, int line)
+void DebuggerManager::haveBreakpoint (const TQString& file, int line)
 {
   setMark(file, line, true, KTextEditor::MarkInterface::markType02);
 }
 
 // The debug server told us we DONT have a breakpoint, remove it
-void DebuggerManager::havenoBreakpoint (const QString& file, int line)
+void DebuggerManager::havenoBreakpoint (const TQString& file, int line)
 {
   DebuggerBreakpoint* br = new DebuggerBreakpoint(file, line);
   m_breakpointList->remove(br);
@@ -584,10 +584,10 @@ void DebuggerManager::havenoBreakpoint (const QString& file, int line)
 }
 
 // New current line
-bool DebuggerManager::setActiveLine (const QString& file, int line )
+bool DebuggerManager::setActiveLine (const TQString& file, int line )
 {
   //Get local filename
-  QString filename = file;
+  TQString filename = file;
 
   // Remove old active line mark
   setMark(m_currentFile, m_currentLine, false, KTextEditor::MarkInterface::markType05);
@@ -614,7 +614,7 @@ bool DebuggerManager::setActiveLine (const QString& file, int line )
 }
 
 // Set/clear a mark in a document
-void DebuggerManager::setMark(const QString& filename, long line, bool set, int mark)
+void DebuggerManager::setMark(const TQString& filename, long line, bool set, int mark)
 {
   if((!filename.isEmpty()) && ViewManager::ref()->isOpened(filename))
   {
@@ -642,26 +642,26 @@ void DebuggerManager::setMark(const QString& filename, long line, bool set, int
 
 void DebuggerManager::connectBreakpointSignals(Document* qdoc)
 {
-  connect(qdoc, SIGNAL(breakpointMarked(Document*, int)),
-    this, SLOT(slotBreakpointMarked(Document*, int)));
+  connect(qdoc, TQT_SIGNAL(breakpointMarked(Document*, int)),
+    this, TQT_SLOT(slotBreakpointMarked(Document*, int)));
 
-  connect(qdoc, SIGNAL(breakpointUnmarked(Document*, int)),
-    this, SLOT(slotBreakpointUnmarked(Document*, int)));
+  connect(qdoc, TQT_SIGNAL(breakpointUnmarked(Document*, int)),
+    this, TQT_SLOT(slotBreakpointUnmarked(Document*, int)));
 }
 
 void DebuggerManager::disconnectBreakpointSignals(Document* qdoc)
 {
-  disconnect(qdoc, SIGNAL(breakpointMarked(Document*, int)),
-    this, SLOT(slotBreakpointMarked(Document*, int)));
+  disconnect(qdoc, TQT_SIGNAL(breakpointMarked(Document*, int)),
+    this, TQT_SLOT(slotBreakpointMarked(Document*, int)));
 
-  disconnect(qdoc, SIGNAL(breakpointUnmarked(Document*, int)),
-    this, SLOT(slotBreakpointUnmarked(Document*, int)));
+  disconnect(qdoc, TQT_SIGNAL(breakpointUnmarked(Document*, int)),
+    this, TQT_SLOT(slotBreakpointUnmarked(Document*, int)));
 }
 
 // Show a status message and optionally put it on the log
-bool DebuggerManager::showStatus(const QString& a_message, bool log)
+bool DebuggerManager::showStatus(const TQString& a_message, bool log)
 {
-  QString message = a_message;
+  TQString message = a_message;
   quantaApp->slotStatusMsg(m_client->getName() + ": " + message);
 
   if(log)
@@ -729,7 +729,7 @@ void DebuggerManager::slotBreakpointMarked(Document* qdoc, int line)
 
 void DebuggerManager::slotBreakpointUnmarked(Document* qdoc, int line)
 {
-  QString filePath = qdoc->url().prettyURL(0, KURL::StripFileProtocol);
+  TQString filePath = qdoc->url().prettyURL(0, KURL::StripFileProtocol);
 
   DebuggerBreakpoint* br = m_breakpointList->retrieve(filePath, line);
 
@@ -744,7 +744,7 @@ void DebuggerManager::slotBreakpointUnmarked(Document* qdoc, int line)
   }
 }
   
-void DebuggerManager::updateBreakpointKey( const DebuggerBreakpoint & bp, const QString & newkey )
+void DebuggerManager::updateBreakpointKey( const DebuggerBreakpoint & bp, const TQString & newkey )
 {
   m_breakpointList->updateBreakpointKey(bp, newkey);
  
@@ -756,7 +756,7 @@ void DebuggerManager::updateBreakpointKey( const DebuggerBreakpoint & bp, const
  
 }
 
-DebuggerBreakpoint * DebuggerManager::findDebuggerBreakpoint( const QString & key )
+DebuggerBreakpoint * DebuggerManager::findDebuggerBreakpoint( const TQString & key )
 {
   return m_breakpointList->findDebuggerBreakpoint(key);
 }
@@ -766,9 +766,9 @@ void DebuggerManager::saveProperties( )
   
   if (m_client)
   {
-    QDomDocument *dom = Project::ref()->sessionDom();
-    QDomNode projectNode = dom->firstChild().firstChild();
-    QDomNode nodeDbg  = projectNode.namedItem("debuggers");
+    TQDomDocument *dom = Project::ref()->sessionDom();
+    TQDomNode projectNode = dom->firstChild().firstChild();
+    TQDomNode nodeDbg  = projectNode.namedItem("debuggers");
     if(nodeDbg.isNull())
     {
       nodeDbg = dom->createElement("debuggers");
@@ -779,7 +779,7 @@ void DebuggerManager::saveProperties( )
     if(Project::ref()->debuggerPersistentBreakpoints())
     {
       // (Re)create breakpoints section
-      QDomNode nodeBreakpoints = nodeDbg.namedItem("breakpoints");
+      TQDomNode nodeBreakpoints = nodeDbg.namedItem("breakpoints");
       if(!nodeBreakpoints.isNull())
         nodeBreakpoints.parentNode().removeChild(nodeBreakpoints);
       
@@ -794,12 +794,12 @@ void DebuggerManager::saveProperties( )
         DebuggerBreakpoint* bp;
         while((bp = m_breakpointList->next()))
         {
-          QDomElement child = dom->createElement("breakpoint");
+          TQDomElement child = dom->createElement("breakpoint");
           child.setAttribute("filepath", bp->filePath());
           child.setAttribute("class", bp->inClass());
           child.setAttribute("function", bp->inFunction());
           child.setAttribute("condition", bp->condition());
-          child.setAttribute("line", QString::number(bp->line()));
+          child.setAttribute("line", TQString::number(bp->line()));
           if(bp->type() == DebuggerBreakpoint::ConditionalTrue)
             child.setAttribute("type", "true");
           else if(bp->type() == DebuggerBreakpoint::ConditionalChange)
@@ -816,7 +816,7 @@ void DebuggerManager::saveProperties( )
     if(Project::ref()->debuggerPersistentWatches())
     {
       // (Re)create watches section
-      QDomNode nodeWatches = nodeDbg.namedItem("watches");
+      TQDomNode nodeWatches = nodeDbg.namedItem("watches");
       if(!nodeWatches.isNull())
         nodeWatches.parentNode().removeChild(nodeWatches);
       
@@ -828,7 +828,7 @@ void DebuggerManager::saveProperties( )
         // Loop watches and save 'em
         for( DebuggerVariable *v = m_debuggerui->watches()->first(); v; v = m_debuggerui->watches()->next())
         {
-          QDomElement child = dom->createElement("watch");
+          TQDomElement child = dom->createElement("watch");
           child.setAttribute("name", v->name());
           
           nodeWatches.appendChild(child);
@@ -838,7 +838,7 @@ void DebuggerManager::saveProperties( )
   }
 }
 
-void DebuggerManager::slotHandleEvent( const QString & event, const QString &, const QString & )
+void DebuggerManager::slotHandleEvent( const TQString & event, const TQString &, const TQString & )
 {
   if(event == "before_project_close")
     saveProperties();
diff --git a/quanta/components/debugger/debuggermanager.h b/quanta/components/debugger/debuggermanager.h
index f7584bdf..5a88b156 100644
--- a/quanta/components/debugger/debuggermanager.h
+++ b/quanta/components/debugger/debuggermanager.h
@@ -18,8 +18,8 @@
 #ifndef PHPDEBUGGERINTERFACE_H
 #define PHPDEBUGGERINTERFACE_H
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class DebuggerClient;
 class QuantaDebuggerInterface;
@@ -49,11 +49,11 @@ class DebuggerManager : public QObject
     void connectBreakpointSignals(Document*);
     void disconnectBreakpointSignals(Document*);
 
-    QString m_currentFile;
+    TQString m_currentFile;
     long m_currentLine;
 
   public:
-    DebuggerManager(QObject *myparent);
+    DebuggerManager(TQObject *myparent);
     ~DebuggerManager();
 
     // Access to memebers
@@ -62,20 +62,20 @@ class DebuggerManager : public QObject
     PathMapper * Mapper() { return m_pathmapper; };
 
     // Breakpoints
-    void haveBreakpoint (const QString& file, int line);
-    void havenoBreakpoint (const QString& file, int line);
+    void haveBreakpoint (const TQString& file, int line);
+    void havenoBreakpoint (const TQString& file, int line);
     void refreshBreakpoints();
 //     DebuggerBreakpoint *newDebuggerBreakpoint();
-    DebuggerBreakpoint * findDebuggerBreakpoint(const QString& key);
-    void updateBreakpointKey(const DebuggerBreakpoint &bp, const QString& newkey);
+    DebuggerBreakpoint * findDebuggerBreakpoint(const TQString& key);
+    void updateBreakpointKey(const DebuggerBreakpoint &bp, const TQString& newkey);
 
     // Public help functions
-    bool showStatus(const QString& message, bool log);
-    bool setActiveLine (const QString& file, int line);
-    void setMark(const QString& filename, long line, bool set, int mark);
+    bool showStatus(const TQString& message, bool log);
+    bool setActiveLine (const TQString& file, int line);
+    void setMark(const TQString& filename, long line, bool set, int mark);
 
-    void enableAction(const QString& action, bool enable);
-    void fileOpened(const QString& file);
+    void enableAction(const TQString& action, bool enable);
+    void fileOpened(const TQString& file);
 
     bool hasClient() { return m_client != 0; };
 
@@ -111,10 +111,10 @@ class DebuggerManager : public QObject
     void slotProfilerOpen();
 
     // Initiation
-    void slotNewProjectLoaded(const QString &, const KURL &, const KURL &);
+    void slotNewProjectLoaded(const TQString &, const KURL &, const KURL &);
 
     // Event handling
-    void slotHandleEvent(const QString &, const QString &, const QString &);
+    void slotHandleEvent(const TQString &, const TQString &, const TQString &);
         
   private slots:
     void slotBreakpointMarked(Document*, int);
diff --git a/quanta/components/debugger/debuggerui.cpp b/quanta/components/debugger/debuggerui.cpp
index c290bd8a..fdf32a5c 100644
--- a/quanta/components/debugger/debuggerui.cpp
+++ b/quanta/components/debugger/debuggerui.cpp
@@ -21,7 +21,7 @@
 #include <kdockwidget.h>
 #include <klocale.h>
 #include <kdebug.h>
-#include <qstring.h>
+#include <tqstring.h>
 #include <khtmlview.h>
 #include <kmditoolviewaccessor.h>
 #include <kstatusbar.h>
@@ -36,8 +36,8 @@
 #include "resource.h"
 #include "whtmlpart.h"
 
-DebuggerUI::DebuggerUI(QObject *parent, const char *name)
-    : QObject(parent, name), m_variablesListView(0)
+DebuggerUI::DebuggerUI(TQObject *parent, const char *name)
+    : TQObject(parent, name), m_variablesListView(0)
 {
 
   // Variable watch tree
@@ -64,14 +64,14 @@ DebuggerUI::DebuggerUI(QObject *parent, const char *name)
   m_preview->view()->setIcon(UserIcon("debug_run"));
   m_preview->view()->setCaption(i18n("Debug Output"));
   m_previewTVA = quantaApp->addToolWindow(m_preview->view(), quantaApp->prevDockPosition(m_preview->view(), KDockWidget::DockBottom), quantaApp->getMainDockWidget());
-  connect(m_preview, SIGNAL(openFile(const KURL&, const QString&, bool)), quantaApp, SLOT(slotFileOpen(const KURL&, const QString&, bool)));
+  connect(m_preview, TQT_SIGNAL(openFile(const KURL&, const TQString&, bool)), quantaApp, TQT_SLOT(slotFileOpen(const KURL&, const TQString&, bool)));
   
   // Show debugger toolbar
   quantaApp->toolBar("debugger_toolbar")->show();
 
-  connect(m_variablesListView, SIGNAL(removeVariable(DebuggerVariable* )), parent, SLOT(slotRemoveVariable(DebuggerVariable* )));
+  connect(m_variablesListView, TQT_SIGNAL(removeVariable(DebuggerVariable* )), parent, TQT_SLOT(slotRemoveVariable(DebuggerVariable* )));
 
-  connect(m_debuggerBreakpointView, SIGNAL(removeBreakpoint(DebuggerBreakpoint* )), parent, SLOT(slotRemoveBreakpoint(DebuggerBreakpoint* )));
+  connect(m_debuggerBreakpointView, TQT_SIGNAL(removeBreakpoint(DebuggerBreakpoint* )), parent, TQT_SLOT(slotRemoveBreakpoint(DebuggerBreakpoint* )));
   showMenu();
 }
 
@@ -99,7 +99,7 @@ DebuggerUI::~DebuggerUI()
 
 void DebuggerUI::showMenu()
 {
-  QPopupMenu* debuggerMenu = (QPopupMenu*)(quantaApp->guiFactory())->container("debugger_menu", quantaApp);
+  TQPopupMenu* debuggerMenu = (TQPopupMenu*)(quantaApp->guiFactory())->container("debugger_menu", quantaApp);
   if(debuggerMenu)
   {
     KMenuBar *mb = quantaApp->menuBar();
@@ -195,7 +195,7 @@ void DebuggerUI::backtraceClear( )
     m_backtraceListview->clear();
 }
 
-void DebuggerUI::backtraceShow( long level, BacktraceType type, const QString & filename, long line, const QString & func )
+void DebuggerUI::backtraceShow( long level, BacktraceType type, const TQString & filename, long line, const TQString & func )
 {
   if(m_backtraceListview)
     m_backtraceListview->backtraceShow(level, type, filename, line, func);
diff --git a/quanta/components/debugger/debuggerui.h b/quanta/components/debugger/debuggerui.h
index a86e4706..767facad 100644
--- a/quanta/components/debugger/debuggerui.h
+++ b/quanta/components/debugger/debuggerui.h
@@ -19,8 +19,8 @@
 #ifndef DEBUGGERUI_H
 #define DEBUGGERUI_H
 
-#include <qobject.h>
-#include <qptrlist.h>
+#include <tqobject.h>
+#include <tqptrlist.h>
 #include <kmditoolviewaccessor.h>
 #include "backtracelistview.h"
 
@@ -49,14 +49,14 @@ class DebuggerUI : public QObject
       HaltedOnBreakpoint
     };
 
-    DebuggerUI(QObject *parent = 0, const char *name = 0);
+    DebuggerUI(TQObject *parent = 0, const char *name = 0);
     ~DebuggerUI();
 
     // Watches
     void addVariable(DebuggerVariable* var);
     void showBreakpoint(const DebuggerBreakpoint& bp);
     void deleteBreakpoint(const DebuggerBreakpoint& bp);
-    void parsePHPVariables(const QString &);
+    void parsePHPVariables(const TQString &);
     void sendRequest(const KURL &url);
     VariablesListView* watches() { return m_variablesListView; };
     
@@ -64,7 +64,7 @@ class DebuggerUI : public QObject
     void hideMenu();
 
     void backtraceClear();
-    void backtraceShow(long level, BacktraceType type, const QString &filename, long line, const QString& func);
+    void backtraceShow(long level, BacktraceType type, const TQString &filename, long line, const TQString& func);
     
   private:
     VariablesListView* m_variablesListView;
diff --git a/quanta/components/debugger/debuggervariable.cpp b/quanta/components/debugger/debuggervariable.cpp
index b6a4f76a..390290a7 100644
--- a/quanta/components/debugger/debuggervariable.cpp
+++ b/quanta/components/debugger/debuggervariable.cpp
@@ -26,7 +26,7 @@ DebuggerVariable::DebuggerVariable()
     , m_item(NULL)
 {}
 
-DebuggerVariable::DebuggerVariable(const QString& name)
+DebuggerVariable::DebuggerVariable(const TQString& name)
     : m_isReference(false)
     , m_size(0)
     , m_type(DebuggerVariableTypes::Undefined)
@@ -35,7 +35,7 @@ DebuggerVariable::DebuggerVariable(const QString& name)
   m_name = name;
 }
 
-DebuggerVariable::DebuggerVariable(const QString& name, const QString& value, int type)
+DebuggerVariable::DebuggerVariable(const TQString& name, const TQString& value, int type)
     : m_isReference(false)
     , m_size(0)
     , m_item(NULL)
@@ -47,7 +47,7 @@ DebuggerVariable::DebuggerVariable(const QString& name, const QString& value, in
     m_size = value.length();
 }
 
-DebuggerVariable::DebuggerVariable(const QString& name, const QString& value, int type, int size)
+DebuggerVariable::DebuggerVariable(const TQString& name, const TQString& value, int type, int size)
     : m_isReference(false)
     , m_item(NULL)
 {
@@ -57,7 +57,7 @@ DebuggerVariable::DebuggerVariable(const QString& name, const QString& value, in
   m_size = size;
 }
 
-DebuggerVariable::DebuggerVariable(const QString& name, const ValueList_t& values, int type)
+DebuggerVariable::DebuggerVariable(const TQString& name, const ValueList_t& values, int type)
     : m_isReference(false)
     , m_item(NULL)
 {
@@ -88,20 +88,20 @@ DebuggerVariable::DebuggerVariable(DebuggerVariable* v, bool copyitem )
 }
 
 
-void DebuggerVariable::setName(const QString& name)
+void DebuggerVariable::setName(const TQString& name)
 {
   m_name = name;
 }
-QString DebuggerVariable::name() const
+TQString DebuggerVariable::name() const
 {
   return m_name;
 }
-void DebuggerVariable::setValue(const QString& value)
+void DebuggerVariable::setValue(const TQString& value)
 {
   m_value = value;
 }
 
-QString DebuggerVariable::value() const
+TQString DebuggerVariable::value() const
 {
   if(isScalar())
     return m_value;
@@ -146,7 +146,7 @@ int DebuggerVariable::type() const
   return m_type;
 }
 
-const QString DebuggerVariable::typeName() const
+const TQString DebuggerVariable::typeName() const
 {
   switch(m_type)
   {
@@ -186,7 +186,7 @@ long DebuggerVariable::size() const
   return m_size;
 }
 
-QString DebuggerVariable::sizeName() const
+TQString DebuggerVariable::sizeName() const
 {
   switch(m_type)
   {
@@ -199,7 +199,7 @@ QString DebuggerVariable::sizeName() const
     case DebuggerVariableTypes::Error:
       return "";
   }
-  return QString::number(m_size);
+  return TQString::number(m_size);
 }
 
 void DebuggerVariable::setReference(bool ref)
@@ -241,7 +241,7 @@ void DebuggerVariable::deleteChild( DebuggerVariable * child )
   }
 }
 
-DebuggerVariable* DebuggerVariable::findItem( QListViewItem * item, bool traverse )
+DebuggerVariable* DebuggerVariable::findItem( TQListViewItem * item, bool traverse )
 {
   if(item == m_item)
     return this;
diff --git a/quanta/components/debugger/debuggervariable.h b/quanta/components/debugger/debuggervariable.h
index 3c83de4b..50d28136 100644
--- a/quanta/components/debugger/debuggervariable.h
+++ b/quanta/components/debugger/debuggervariable.h
@@ -19,8 +19,8 @@
 #ifndef DEBUGGERVARIABLE_H
 #define DEBUGGERVARIABLE_H
 
-#include <qstring.h>
-#include <qptrlist.h>
+#include <tqstring.h>
+#include <tqptrlist.h>
 #include <klistview.h>
 
 namespace DebuggerVariableTypes
@@ -41,38 +41,38 @@ namespace DebuggerVariableTypes
 }
 
 class DebuggerVariable;
-typedef QPtrList<DebuggerVariable> ValueList_t;
+typedef TQPtrList<DebuggerVariable> ValueList_t;
 
 class DebuggerVariable
 {
   public:
     DebuggerVariable();
     DebuggerVariable(DebuggerVariable* var, bool copyitem = false);
-    DebuggerVariable(const QString& name);
-    DebuggerVariable(const QString& name, const QString& value, int type);
-    DebuggerVariable(const QString& name, const QString& value, int type, int size);
-    DebuggerVariable(const QString& name, const ValueList_t& values, int type);
+    DebuggerVariable(const TQString& name);
+    DebuggerVariable(const TQString& name, const TQString& value, int type);
+    DebuggerVariable(const TQString& name, const TQString& value, int type, int size);
+    DebuggerVariable(const TQString& name, const ValueList_t& values, int type);
     virtual ~DebuggerVariable();
 
-    DebuggerVariable* findItem(QListViewItem *item, bool traverse = false);
+    DebuggerVariable* findItem(TQListViewItem *item, bool traverse = false);
     
-    virtual void setName(const QString& name);
-    virtual QString name() const;
+    virtual void setName(const TQString& name);
+    virtual TQString name() const;
 
-    virtual void setValue(const QString& value);
-    virtual QString value() const;
+    virtual void setValue(const TQString& value);
+    virtual TQString value() const;
 
     virtual void setValues(const ValueList_t& valueList);
     virtual ValueList_t values() const;
 
     virtual void setType(int type);
     virtual int type() const;
-    virtual const QString typeName() const ;
+    virtual const TQString typeName() const ;
     virtual bool isScalar() const;
 
     virtual void setSize(long size);
     virtual long size() const;
-    virtual QString sizeName() const;
+    virtual TQString sizeName() const;
 
     virtual void setReference(bool ref);
     virtual bool isReference() const;
@@ -91,8 +91,8 @@ class DebuggerVariable
   private:
     ValueList_t m_valueList;
 
-    QString m_name;
-    QString m_value;
+    TQString m_name;
+    TQString m_value;
     bool    m_isReference;
     long    m_size;
     int     m_type;
diff --git a/quanta/components/debugger/gubed/gubedsettings.cpp b/quanta/components/debugger/gubed/gubedsettings.cpp
index f728d884..9464dc81 100644
--- a/quanta/components/debugger/gubed/gubedsettings.cpp
+++ b/quanta/components/debugger/gubed/gubedsettings.cpp
@@ -15,11 +15,11 @@
  ***************************************************************************/
 
 
-#include "qlineedit.h"
+#include "tqlineedit.h"
 #include "gubedsettings.h"
 #include <ktextbrowser.h>
 
-GubedSettings::GubedSettings(const QString &protocolversion)
+GubedSettings::GubedSettings(const TQString &protocolversion)
     : GubedSettingsS(0, "GubedSettings", false, 0)
 {
   textAbout->setText(textAbout->text().replace("%PROTOCOLVERSION%", protocolversion));
diff --git a/quanta/components/debugger/gubed/gubedsettings.h b/quanta/components/debugger/gubed/gubedsettings.h
index dc070f32..73232e06 100644
--- a/quanta/components/debugger/gubed/gubedsettings.h
+++ b/quanta/components/debugger/gubed/gubedsettings.h
@@ -27,7 +27,7 @@ class GubedSettings : public GubedSettingsS
     virtual void slotUseProxyToggle( bool useproxy);
 
   public:
-    GubedSettings(const QString &protocolversion);
+    GubedSettings(const TQString &protocolversion);
     ~GubedSettings();
 
 };
diff --git a/quanta/components/debugger/gubed/quantadebuggergubed.cpp b/quanta/components/debugger/gubed/quantadebuggergubed.cpp
index be703e73..f909832a 100644
--- a/quanta/components/debugger/gubed/quantadebuggergubed.cpp
+++ b/quanta/components/debugger/gubed/quantadebuggergubed.cpp
@@ -19,14 +19,14 @@
 #include <kstreamsocket.h>
 #include <klocale.h>
 #include <kgenericfactory.h>
-#include <qlineedit.h>
-#include <qslider.h>
-#include <qcheckbox.h>
-#include <qcombobox.h>
+#include <tqlineedit.h>
+#include <tqslider.h>
+#include <tqcheckbox.h>
+#include <tqcombobox.h>
 #include <kdeversion.h>
 #include <errno.h>
-#include <qstring.h>
-#include <qmap.h>
+#include <tqstring.h>
+#include <tqmap.h>
 
 #include <stdarg.h>
 
@@ -47,7 +47,7 @@ K_EXPORT_COMPONENT_FACTORY( quantadebuggergubed,
 
 const char QuantaDebuggerGubed::protocolversion[] = "0.0.12";
 
-QuantaDebuggerGubed::QuantaDebuggerGubed (QObject *parent, const char* name, const QStringList&)
+QuantaDebuggerGubed::QuantaDebuggerGubed (TQObject *parent, const char* name, const TQStringList&)
     : DebuggerClient (parent, name)
 {
   // Create a socket object and set up its signals
@@ -98,10 +98,10 @@ void QuantaDebuggerGubed::startSession()
     {
       m_socket = new KNetwork::KStreamSocket(m_serverHost, m_serverPort);
 
-      connect(m_socket, SIGNAL(gotError(int)), this, SLOT(slotError(int)));
-      connect(m_socket, SIGNAL(connected(const KResolverEntry &)), this, SLOT(slotConnected(const KResolverEntry &)));
-      connect(m_socket, SIGNAL(closed()), this, SLOT(slotConnectionClosed()));
-      connect(m_socket, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
+      connect(m_socket, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotError(int)));
+      connect(m_socket, TQT_SIGNAL(connected(const KResolverEntry &)), this, TQT_SLOT(slotConnected(const KResolverEntry &)));
+      connect(m_socket, TQT_SIGNAL(closed()), this, TQT_SLOT(slotConnectionClosed()));
+      connect(m_socket, TQT_SIGNAL(readyRead()), this, TQT_SLOT(slotReadyRead()));
 
       m_socket->connect();
       debuggerInterface()->enableAction("debug_connect", true);
@@ -119,7 +119,7 @@ void QuantaDebuggerGubed::startSession()
       m_server = new KNetwork::KServerSocket(m_listenPort);
 
       m_server->setAddressReuseable(true);
-      connect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
+      connect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
 
       if(m_server->listen())
       {
@@ -280,7 +280,7 @@ void QuantaDebuggerGubed::slotReadyAccept()
   {
 
     // Perhaps this shouldnt be disconnected - instead check if connections are available at disconnect?
-    disconnect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
+    disconnect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
 
     m_socket = (KNetwork::KStreamSocket *)m_server->accept(); // KSocketServer returns a KStreamSocket (!)
     if(m_socket)
@@ -288,10 +288,10 @@ void QuantaDebuggerGubed::slotReadyAccept()
       kdDebug(24002) << k_funcinfo << ", ready" << endl;
       m_socket->enableRead(true);
 
-      connect(m_socket, SIGNAL(gotError(int)), this, SLOT(slotError(int)));
-      connect(m_socket, SIGNAL(connected(const KResolverEntry &)), this, SLOT(slotConnected(const KResolverEntry &)));
-      connect(m_socket, SIGNAL(closed()), this, SLOT(slotConnectionClosed()));
-      connect(m_socket, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
+      connect(m_socket, TQT_SIGNAL(gotError(int)), this, TQT_SLOT(slotError(int)));
+      connect(m_socket, TQT_SIGNAL(connected(const KResolverEntry &)), this, TQT_SLOT(slotConnected(const KResolverEntry &)));
+      connect(m_socket, TQT_SIGNAL(closed()), this, TQT_SLOT(slotConnectionClosed()));
+      connect(m_socket, TQT_SIGNAL(readyRead()), this, TQT_SLOT(slotReadyRead()));
       connected();
 
       emit updateStatus(DebuggerUI::Connected);
@@ -339,7 +339,7 @@ void QuantaDebuggerGubed::slotConnectionClosed()
   }
 
   if(m_server)
-    connect(m_server, SIGNAL(readyAccept()), this, SLOT(slotReadyAccept()));
+    connect(m_server, TQT_SIGNAL(readyAccept()), this, TQT_SLOT(slotReadyAccept()));
 
   // Disable all session related actions and enable connection action
   debuggerInterface()->enableAction("*", false);
@@ -365,7 +365,7 @@ void QuantaDebuggerGubed::slotReadyRead()
   while(m_socket && (m_socket->bytesAvailable() > 0 || m_buffer.length() >= (unsigned long)m_datalen))
   {
     int bytes;
-    QString data;
+    TQString data;
 
     if(m_socket && m_socket->bytesAvailable() > 0)
     {
@@ -408,7 +408,7 @@ void QuantaDebuggerGubed::slotReadyRead()
 }
 
 // Process a gubed command
-void QuantaDebuggerGubed::processCommand(const QString& datas)
+void QuantaDebuggerGubed::processCommand(const TQString& datas)
 {
   kdDebug(24002) << k_funcinfo << ", " << m_command << " : " << datas.left(50) << endl;
   StringMap args = parseArgs(datas);
@@ -429,7 +429,7 @@ void QuantaDebuggerGubed::processCommand(const QString& datas)
   else if(m_command == "getrunmode")
   {
     debuggingState(true);
-    sendCommand("setdisplaydelay", "newdelay", QString::number(m_displaydelay).ascii(), (char*)0L);
+    sendCommand("setdisplaydelay", "newdelay", TQString::number(m_displaydelay).ascii(), (char*)0L);
     if(m_executionState == Pause)
       sendCommand("pause", (char*)0L);
     else if(m_executionState == Run)
@@ -437,15 +437,15 @@ void QuantaDebuggerGubed::processCommand(const QString& datas)
     else if(m_executionState == Trace)
       sendCommand("trace", (char*)0L);
 
-    sendCommand("seterrormask", "errormask", QString::number(m_errormask).ascii(), (char*)0L);
+    sendCommand("seterrormask", "errormask", TQString::number(m_errormask).ascii(), (char*)0L);
   }
   // Just some status info, display on status line
   else if(m_command == "status")
   {
     long argcnt = args["args"].toLong();
-    QString msg = i18n(args["message"]);  // How will we get these messages throught to the translators?
+    TQString msg = i18n(args["message"]);  // How will we get these messages throught to the translators?
     for(int cnt = 1; cnt <= argcnt; cnt++)
-      msg.replace("%" + QString("%1").arg(cnt) + "%", args[QString("arg%1").arg(cnt)]);
+      msg.replace("%" + TQString("%1").arg(cnt) + "%", args[TQString("arg%1").arg(cnt)]);
 
     debuggerInterface()->showStatus(msg, false);
   }
@@ -588,28 +588,28 @@ void QuantaDebuggerGubed::sendBreakpoints()
 }
 void QuantaDebuggerGubed::sendWatches()
 {
-  for(QValueList<QString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
+  for(TQValueList<TQString>::iterator it = m_watchlist.begin(); it != m_watchlist.end(); ++it)
     sendCommand("getwatch", "variable", (*it).ascii(), (char*)0L);
   sendCommand("sentwatches", "key", (char*)0L, (char*)0L);
 }
 
 // Send a command to gubed
-bool QuantaDebuggerGubed::sendCommand(const QString& command, StringMap args)
+bool QuantaDebuggerGubed::sendCommand(const TQString& command, StringMap args)
 {
 
   kdDebug(24002) << k_lineinfo << ", command " << command << " with data: " << phpSerialize(args) << endl;
   if(!m_socket || m_socket->state() != KNetwork::KClientSocketBase::Connected)
     return false;
 
-  QString buffer = phpSerialize(args);
+  TQString buffer = phpSerialize(args);
 
-  buffer = QString(command + ":%1;" + buffer).arg(buffer.length());
+  buffer = TQString(command + ":%1;" + buffer).arg(buffer.length());
   m_socket->writeBlock(buffer, buffer.length());
   return true;
 }
 
 // Send a command to gubed
-bool QuantaDebuggerGubed::sendCommand(const QString& command, char * firstarg, ...)
+bool QuantaDebuggerGubed::sendCommand(const TQString& command, char * firstarg, ...)
 {
   StringMap ca;
   char *next;
@@ -620,7 +620,7 @@ bool QuantaDebuggerGubed::sendCommand(const QString& command, char * firstarg, .
   next = firstarg;
   while(next)
   {
-    ca[(QString)next] = (QString)va_arg(l_Arg, char*);
+    ca[(TQString)next] = (TQString)va_arg(l_Arg, char*);
 //     kdDebug(24002) << k_lineinfo << " Added arg/valuepair " << next << ", " << ca[next].left(30) << endl;
     next = va_arg(l_Arg, char*);
   }
@@ -631,12 +631,12 @@ bool QuantaDebuggerGubed::sendCommand(const QString& command, char * firstarg, .
 }
 
 // Return name of debugger
-QString QuantaDebuggerGubed::getName()
+TQString QuantaDebuggerGubed::getName()
 {
   return "Gubed";      // no i18n on the name
 }
 
-void QuantaDebuggerGubed::showWatch(const QString& data)
+void QuantaDebuggerGubed::showWatch(const TQString& data)
 {
   debuggerInterface()->showVariable(parsePHPVariables(data));
 }
@@ -644,7 +644,7 @@ void QuantaDebuggerGubed::showWatch(const QString& data)
 // Send HTTP Request
 void QuantaDebuggerGubed::request()
 {
-  QString request;
+  TQString request;
   request = debuggerInterface()->activeFileParts(m_startsession);
 
   //if(request.startsWith(m_localBasedir, false))
@@ -711,7 +711,7 @@ void QuantaDebuggerGubed::pause()
 // Add a breakpoint
 void QuantaDebuggerGubed::addBreakpoint (DebuggerBreakpoint* breakpoint)
 {
-  QString type;
+  TQString type;
   if(breakpoint->type() == DebuggerBreakpoint::LineBreakpoint)
     type = "line";
   else if(breakpoint->type() == DebuggerBreakpoint::ConditionalTrue)
@@ -725,13 +725,13 @@ void QuantaDebuggerGubed::addBreakpoint (DebuggerBreakpoint* breakpoint)
               "class", breakpoint->inClass().ascii(),
               "function", breakpoint->inFunction().ascii(),
               "expression", breakpoint->condition().ascii(),
-              "line", QString::number(breakpoint->line()).ascii(),
+              "line", TQString::number(breakpoint->line()).ascii(),
               (char *)0L);
 }
 
-// QString QuantaDebuggerGubed::bpToGubed(DebuggerBreakpoint* breakpoint)
+// TQString QuantaDebuggerGubed::bpToGubed(DebuggerBreakpoint* breakpoint)
 // {
-//   return QString("^" + mapLocalPathToServer(breakpoint->filePath()) +
+//   return TQString("^" + mapLocalPathToServer(breakpoint->filePath()) +
 //       "^" + breakpoint->inClass() +
 //       "^" + breakpoint->inFunction() +
 //       "^" + (breakpoint->type() == DebuggerBreakpoint::ConditionalTrue ? "true" : "change") +
@@ -741,7 +741,7 @@ void QuantaDebuggerGubed::addBreakpoint (DebuggerBreakpoint* breakpoint)
 // Clear a breakpoint
 void QuantaDebuggerGubed::removeBreakpoint(DebuggerBreakpoint* breakpoint)
 {
-  QString type;
+  TQString type;
   if(breakpoint->type() == DebuggerBreakpoint::LineBreakpoint)
     type = "line";
   else if(breakpoint->type() == DebuggerBreakpoint::ConditionalTrue)
@@ -755,18 +755,18 @@ void QuantaDebuggerGubed::removeBreakpoint(DebuggerBreakpoint* breakpoint)
               "class", breakpoint->inClass().ascii(),
               "function", breakpoint->inFunction().ascii(),
               "expression", breakpoint->condition().ascii(),
-              "line", QString::number(breakpoint->line()).ascii(),
+              "line", TQString::number(breakpoint->line()).ascii(),
               (char*)0L);
 }
 
 // A file was opened...
-void QuantaDebuggerGubed::fileOpened(const QString&)
+void QuantaDebuggerGubed::fileOpened(const TQString&)
 {
   sendCommand("reinitialize", (char*)0L);
 }
 
 // Watch a variable
-void QuantaDebuggerGubed::addWatch(const QString &variable)
+void QuantaDebuggerGubed::addWatch(const TQString &variable)
 {
   if(m_watchlist.find(variable) == m_watchlist.end())
     m_watchlist.append(variable);
@@ -798,10 +798,10 @@ void QuantaDebuggerGubed::showCondition(const StringMap &args)
 }
 
 // Read configuration
-void QuantaDebuggerGubed::readConfig(QDomNode node)
+void QuantaDebuggerGubed::readConfig(TQDomNode node)
 {
   // Server
-  QDomNode valuenode = node.namedItem("serverhost");
+  TQDomNode valuenode = node.namedItem("serverhost");
   m_serverHost = valuenode.firstChild().nodeValue();
   if(m_serverHost.isEmpty())
     m_serverHost = "localhost";
@@ -850,7 +850,7 @@ void QuantaDebuggerGubed::readConfig(QDomNode node)
 
 
 // Show configuration
-void QuantaDebuggerGubed::showConfig(QDomNode node)
+void QuantaDebuggerGubed::showConfig(TQDomNode node)
 {
   GubedSettings set(protocolversion);
 
@@ -872,9 +872,9 @@ void QuantaDebuggerGubed::showConfig(QDomNode node)
   set.checkBreakOnUserWarning->setChecked(QuantaDebuggerGubed::User_Warning & m_errormask);
   set.checkBreakOnUserError->setChecked(QuantaDebuggerGubed::User_Error & m_errormask);
 
-  if(set.exec() == QDialog::Accepted )
+  if(set.exec() == TQDialog::Accepted )
   {
-    QDomElement el;
+    TQDomElement el;
 
     el = node.namedItem("serverhost").toElement();
     if (!el.isNull())
@@ -942,7 +942,7 @@ void QuantaDebuggerGubed::showConfig(QDomNode node)
     el = node.ownerDocument().createElement("defaultexecutionstate");
     node.appendChild( el );
     m_defaultExecutionState = (State)set.comboDefaultExecutionState->currentItem();
-    el.appendChild(node.ownerDocument().createTextNode(QString::number(m_defaultExecutionState)));
+    el.appendChild(node.ownerDocument().createTextNode(TQString::number(m_defaultExecutionState)));
 
 
     el = node.namedItem("displaydelay").toElement();
@@ -951,7 +951,7 @@ void QuantaDebuggerGubed::showConfig(QDomNode node)
     el = node.ownerDocument().createElement("displaydelay");
     node.appendChild( el );
     m_displaydelay = set.sliderDisplayDelay->value();
-    el.appendChild( node.ownerDocument().createTextNode(QString::number(m_displaydelay)));
+    el.appendChild( node.ownerDocument().createTextNode(TQString::number(m_displaydelay)));
 
     el = node.namedItem("errormask").toElement();
     if (!el.isNull())
@@ -964,20 +964,20 @@ void QuantaDebuggerGubed::showConfig(QDomNode node)
                   + (set.checkBreakOnUserWarning->isChecked() ? QuantaDebuggerGubed::User_Warning : 0)
                   + (set.checkBreakOnUserError->isChecked() ? QuantaDebuggerGubed::User_Error : 0);
     kdDebug(24002) << k_funcinfo << ", m_errormask = " << m_errormask << endl;
-    el.appendChild( node.ownerDocument().createTextNode(QString::number(m_errormask)));
+    el.appendChild( node.ownerDocument().createTextNode(TQString::number(m_errormask)));
 
   }
 }
 
 // Map a server filepath to a local one using project settings
-QString QuantaDebuggerGubed::mapServerPathToLocal(const QString& serverpath)
+TQString QuantaDebuggerGubed::mapServerPathToLocal(const TQString& serverpath)
 {
   // Translate filename from server to local
   return debuggerInterface()->Mapper()->mapServerPathToLocal(serverpath);
 }
 
 // Map a local filepath to a server one using project settings
-QString QuantaDebuggerGubed::mapLocalPathToServer(const QString& localpath)
+TQString QuantaDebuggerGubed::mapLocalPathToServer(const TQString& localpath)
 {
   // Translate filename from local to server
   return debuggerInterface()->Mapper()->mapLocalPathToServer(localpath);
@@ -991,23 +991,23 @@ void QuantaDebuggerGubed::variableSetValue(const DebuggerVariable &variable)
               (char*)0L);
 }
 
-QString QuantaDebuggerGubed::phpSerialize(StringMap args)
+TQString QuantaDebuggerGubed::phpSerialize(StringMap args)
 {
   StringMap::Iterator it;
   // a:2:{s:4:"name";s:7:"Jessica";s:3:"age";s:2:"26";s:4:"test";i:1;}
-  QString ret = QString("a:%1:{").arg(args.size());
+  TQString ret = TQString("a:%1:{").arg(args.size());
   for( it = args.begin(); it != args.end(); ++it )
   {
     bool isNumber;
 
     it.data().toInt(&isNumber);
     if(isNumber && !it.data().isEmpty())
-      ret += QString("s:%1:\"%2\";i:%3;")
+      ret += TQString("s:%1:\"%2\";i:%3;")
                     .arg(it.key().length())
                     .arg(it.key())
                     .arg(it.data());
     else
-      ret += QString("s:%1:\"%2\";s:%3:\"%4\";")
+      ret += TQString("s:%1:\"%2\";s:%3:\"%4\";")
                     .arg(it.key().length())
                     .arg(it.key())
                     .arg(it.data().length())
@@ -1020,7 +1020,7 @@ QString QuantaDebuggerGubed::phpSerialize(StringMap args)
 }
 
 
-StringMap QuantaDebuggerGubed::parseArgs(const QString &args)
+StringMap QuantaDebuggerGubed::parseArgs(const TQString &args)
 {
   StringMap ca;
   long cnt, length;
@@ -1039,9 +1039,9 @@ StringMap QuantaDebuggerGubed::parseArgs(const QString &args)
   }
 
   cnt = args.mid(2, args.find("{") - 3).toLong();
-  QString data = args.mid(args.find("{") + 1);
+  TQString data = args.mid(args.find("{") + 1);
 
-  QString tmp, func;
+  TQString tmp, func;
   while(cnt > 0)
   {
     tmp = data.left(data.find("\""));
@@ -1076,22 +1076,22 @@ StringMap QuantaDebuggerGubed::parseArgs(const QString &args)
   return ca;
 }
 
-DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(const QString &varstring)
+DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(const TQString &varstring)
 {
-  QString str = varstring;
+  TQString str = varstring;
   DebuggerVariable* var = parsePHPVariables(str);
   return var;
 }
 
-DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(QString &str)
+DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(TQString &str)
 {
-  QString key, data;
-  QString tempstring;
+  TQString key, data;
+  TQString tempstring;
   int length;
   DebuggerVariable* debuggervar = NULL;
 
   // get type of key
-  QString type = str.left(1);
+  TQString type = str.left(1);
   str.remove(0, 2);
 
   // Strings
@@ -1172,7 +1172,7 @@ DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(QString &str)
     str.remove(0, str.find(':') + 2);
     length = tempstring.toUInt();
 
-    QPtrList<DebuggerVariable> vars ;
+    TQPtrList<DebuggerVariable> vars ;
     while(length > 0)
     {
      //kdDebug(24002) << "VariablesListView::parsePHPVariables: length " << length << ", \"" << str << "\"" << endl;
@@ -1201,7 +1201,7 @@ DebuggerVariable* QuantaDebuggerGubed::parsePHPVariables(QString &str)
 
     str.remove(0, str.find('{') + 1);
     
-    QPtrList<DebuggerVariable> vars ;
+    TQPtrList<DebuggerVariable> vars ;
     while(length > 0)
     {
      //kdDebug(24002) << "VariablesListView::parsePHPVariables: length " << length << ", \"" << str << "\"" << endl;
diff --git a/quanta/components/debugger/gubed/quantadebuggergubed.h b/quanta/components/debugger/gubed/quantadebuggergubed.h
index 62acac0b..0f41b804 100644
--- a/quanta/components/debugger/gubed/quantadebuggergubed.h
+++ b/quanta/components/debugger/gubed/quantadebuggergubed.h
@@ -19,21 +19,21 @@
 
 #include <kserversocket.h>
 #include <kstreamsocket.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 #include <kurl.h>
-#include <qdom.h>
+#include <tqdom.h>
 
 #include "debuggerclient.h"
 
-typedef QValueList<QString> WatchList;
-typedef QMap<QString, QString> StringMap;
+typedef TQValueList<TQString> WatchList;
+typedef TQMap<TQString, TQString> StringMap;
 
 class QuantaDebuggerGubed : public DebuggerClient
 {
     Q_OBJECT
 
   public:
-    QuantaDebuggerGubed(QObject *parent, const char* name, const QStringList&);
+    QuantaDebuggerGubed(TQObject *parent, const char* name, const TQStringList&);
     ~QuantaDebuggerGubed();
 
     // Execution states
@@ -76,14 +76,14 @@ class QuantaDebuggerGubed : public DebuggerClient
     void endSession();
 
     // Return name of debugger
-    QString getName();
+    TQString getName();
 
     // New file opened in quanta
-    void fileOpened(const QString& file);
+    void fileOpened(const TQString& file);
 
     // Settings
-    void readConfig(QDomNode node);
-    void showConfig(QDomNode node);
+    void readConfig(TQDomNode node);
+    void showConfig(TQDomNode node);
 
     // Breakpoints
     void addBreakpoint(DebuggerBreakpoint* breakpoint);
@@ -91,22 +91,22 @@ class QuantaDebuggerGubed : public DebuggerClient
     void showCondition(const StringMap &args);
 
     // Variables
-    void addWatch(const QString &variable);
+    void addWatch(const TQString &variable);
     void removeWatch(DebuggerVariable *var);
     void variableSetValue(const DebuggerVariable &variable);
 
   private:
     KNetwork::KStreamSocket *m_socket;
     KNetwork::KServerSocket *m_server;
-    QString m_command, m_buffer;
+    TQString m_command, m_buffer;
     long    m_datalen;
 
-    QString m_serverBasedir;
-    QString m_localBasedir;
-    QString m_serverPort;
-    QString m_serverHost;
-    QString m_startsession;
-    QString m_listenPort;
+    TQString m_serverBasedir;
+    TQString m_localBasedir;
+    TQString m_serverPort;
+    TQString m_serverHost;
+    TQString m_startsession;
+    TQString m_listenPort;
     bool    m_useproxy;
     State   m_executionState, m_defaultExecutionState;
     long    m_errormask;
@@ -114,28 +114,28 @@ class QuantaDebuggerGubed : public DebuggerClient
 
     WatchList m_watchlist;
 
-//     bool sendCommand(const QString&, const QString&);
-    bool sendCommand(const QString& command, StringMap args);
-    bool sendCommand(const QString& command, char * firstarg, ...);
+//     bool sendCommand(const TQString&, const TQString&);
+    bool sendCommand(const TQString& command, StringMap args);
+    bool sendCommand(const TQString& command, char * firstarg, ...);
 
-    void processCommand(const QString&);
+    void processCommand(const TQString&);
     void sendWatches();
     void sendBreakpoints();
     void debuggingState(bool enable);
     void connected();
 
-    QString mapServerPathToLocal(const QString& serverpath);
-    QString mapLocalPathToServer(const QString& localpath);
-    QString bpToGubed(DebuggerBreakpoint* breakpoint);
+    TQString mapServerPathToLocal(const TQString& serverpath);
+    TQString mapLocalPathToServer(const TQString& localpath);
+    TQString bpToGubed(DebuggerBreakpoint* breakpoint);
 
     // Communication helpers
-    QString phpSerialize(StringMap args);
-    StringMap parseArgs(const QString &args);
+    TQString phpSerialize(StringMap args);
+    StringMap parseArgs(const TQString &args);
 
     // Variables
-    DebuggerVariable* parsePHPVariables(const QString &varstring);
-    DebuggerVariable* parsePHPVariables(QString &str);
-    void showWatch(const QString& data);
+    DebuggerVariable* parsePHPVariables(const TQString &varstring);
+    DebuggerVariable* parsePHPVariables(TQString &str);
+    void showWatch(const TQString& data);
 
     
   public slots:
diff --git a/quanta/components/debugger/interfaces/debuggerclient.cpp b/quanta/components/debugger/interfaces/debuggerclient.cpp
index 8c3196d9..97140dbb 100644
--- a/quanta/components/debugger/interfaces/debuggerclient.cpp
+++ b/quanta/components/debugger/interfaces/debuggerclient.cpp
@@ -23,8 +23,8 @@
 
 
 // CTor
-DebuggerClient::DebuggerClient(QObject *parent, const char* name)
- : QObject(parent, name)
+DebuggerClient::DebuggerClient(TQObject *parent, const char* name)
+ : TQObject(parent, name)
 {
   m_active = false;
 }
@@ -41,7 +41,7 @@ bool DebuggerClient::isActive()
   return m_active;
 }
 
-void DebuggerClient::unSupportedAction(const QString &action)
+void DebuggerClient::unSupportedAction(const TQString &action)
 {
   KMessageBox::error(NULL, i18n("The current debugger, %1, does not support the \"%2\" instruction.").arg(this->getName()).arg(action), i18n("Unsupported Debugger Function"));
 
@@ -107,7 +107,7 @@ void DebuggerClient::profilerOpen( )
 }
 
 // Unimplemented defaults
-void DebuggerClient::fileOpened(const QString&)
+void DebuggerClient::fileOpened(const TQString&)
 {
    return;
 }
@@ -127,19 +127,19 @@ void DebuggerClient::removeBreakpoint(DebuggerBreakpoint*)
 
 
 // Unimplemented defaults
-void DebuggerClient::showConfig(QDomNode)
+void DebuggerClient::showConfig(TQDomNode)
 {
    KMessageBox::error(NULL, i18n("%1 does not have any specific settings.").arg(this->getName()), i18n("Settings"));
 }
 
 // Unimplemented defaults
-void DebuggerClient::readConfig(QDomNode)
+void DebuggerClient::readConfig(TQDomNode)
 {
 
 }
 
 //  Unimplemented defaults: add watch
-void DebuggerClient::addWatch(const QString &)
+void DebuggerClient::addWatch(const TQString &)
 {
   KMessageBox::error(NULL, i18n("%1 does not support watches.").arg(this->getName()), i18n("Unsupported Debugger Function"));
 }
diff --git a/quanta/components/debugger/interfaces/debuggerclient.h b/quanta/components/debugger/interfaces/debuggerclient.h
index d50526cc..1966039f 100644
--- a/quanta/components/debugger/interfaces/debuggerclient.h
+++ b/quanta/components/debugger/interfaces/debuggerclient.h
@@ -18,10 +18,10 @@
 #ifndef _DEBUGGERCLIENT_H
 #define _DEBUGGERCLIENT_H
 
-#include <qserversocket.h>
-#include <qobject.h>
+#include <tqserversocket.h>
+#include <tqobject.h>
 #include <kurl.h>
-#include <qdom.h>
+#include <tqdom.h>
 
 #include "debuggerui.h"
 
@@ -66,7 +66,7 @@ class DebuggerClient : public QObject
 
   private:
   protected:
-    DebuggerClient(QObject *parent, const char* name);
+    DebuggerClient(TQObject *parent, const char* name);
 
     bool m_active;
 
@@ -74,7 +74,7 @@ class DebuggerClient : public QObject
     virtual const uint supports(DebuggerClientCapabilities::Capabilities) = 0;
     virtual void startSession() = 0;
     virtual void endSession() = 0;
-    virtual QString getName() = 0;
+    virtual TQString getName() = 0;
 
     // Execution control
     virtual void request();
@@ -88,21 +88,21 @@ class DebuggerClient : public QObject
     virtual void pause();
 
     // Settings
-    virtual void readConfig(QDomNode node);
-    virtual void showConfig(QDomNode node);
+    virtual void readConfig(TQDomNode node);
+    virtual void showConfig(TQDomNode node);
 
     // Profiler
     virtual void profilerOpen();
 
     // Misc
-    virtual void fileOpened(const QString& file);
+    virtual void fileOpened(const TQString& file);
     virtual void addBreakpoint(DebuggerBreakpoint* breakpoint);
     virtual void removeBreakpoint(DebuggerBreakpoint* breakpoint);
-    virtual void addWatch(const QString &);
+    virtual void addWatch(const TQString &);
     virtual void removeWatch(DebuggerVariable*);
     virtual void variableSetValue(const DebuggerVariable &variable);
 
-    void unSupportedAction(const QString &action);
+    void unSupportedAction(const TQString &action);
 
     bool isActive();
     DebuggerInterface *debuggerInterface();
diff --git a/quanta/components/debugger/interfaces/debuggerinterface.cpp b/quanta/components/debugger/interfaces/debuggerinterface.cpp
index 5481180c..4d7beda6 100644
--- a/quanta/components/debugger/interfaces/debuggerinterface.cpp
+++ b/quanta/components/debugger/interfaces/debuggerinterface.cpp
@@ -17,8 +17,8 @@
 
 #include "debuggerinterface.h"
 
-DebuggerInterface::DebuggerInterface (QObject *parent, const char* name)
-    : QObject(parent, name)
+DebuggerInterface::DebuggerInterface (TQObject *parent, const char* name)
+    : TQObject(parent, name)
 {
 }
 
diff --git a/quanta/components/debugger/interfaces/debuggerinterface.h b/quanta/components/debugger/interfaces/debuggerinterface.h
index 8c527979..1540a616 100644
--- a/quanta/components/debugger/interfaces/debuggerinterface.h
+++ b/quanta/components/debugger/interfaces/debuggerinterface.h
@@ -18,8 +18,8 @@
 #ifndef DEBUGGERINTERFACE_H
 #define DEBUGGERINTERFACE_H
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 #include <kurl.h>
 
 #include "debuggervariable.h"
@@ -36,40 +36,40 @@ class DebuggerInterface : public QObject
 
 
   public:
-    DebuggerInterface(QObject *parent, const char* name);
+    DebuggerInterface(TQObject *parent, const char* name);
 
     // Breakpoints
-    virtual void haveBreakpoint (const QString& file, int line) = 0;
-    virtual void havenoBreakpoint (const QString& file, int line) = 0;
+    virtual void haveBreakpoint (const TQString& file, int line) = 0;
+    virtual void havenoBreakpoint (const TQString& file, int line) = 0;
 
     // Public help functions
-    virtual bool showStatus(const QString& message, bool log) = 0;
-    virtual bool setActiveLine (const QString& file, int line) = 0;
+    virtual bool showStatus(const TQString& message, bool log) = 0;
+    virtual bool setActiveLine (const TQString& file, int line) = 0;
 
-    virtual void enableAction(const QString& action, bool enable) = 0;
-    virtual void fileOpened(const QString& file) = 0;
+    virtual void enableAction(const TQString& action, bool enable) = 0;
+    virtual void fileOpened(const TQString& file) = 0;
     virtual void sendRequest(const KURL &url) = 0;
-    virtual const QString activeFileParts(const QString & str) = 0;
+    virtual const TQString activeFileParts(const TQString & str) = 0;
 
     // Watch handling
     //virtual void preWatchUpdate() = 0;
     //virtual void postWatchUpdate() = 0;
 
-    virtual DebuggerVariable* newDebuggerVariable(const QString& name, const QString& value, int type) = 0;
-    virtual DebuggerVariable* newDebuggerVariable(const QString& name, const ValueList_t& values, int type) = 0;
+    virtual DebuggerVariable* newDebuggerVariable(const TQString& name, const TQString& value, int type) = 0;
+    virtual DebuggerVariable* newDebuggerVariable(const TQString& name, const ValueList_t& values, int type) = 0;
     virtual void showVariable(DebuggerVariable*) = 0;
 
     // Backtrace
     virtual void backtraceClear() = 0;
-    virtual void backtraceShow(long level, BacktraceType type, const QString &filename, long line, const QString& func) = 0;
+    virtual void backtraceShow(long level, BacktraceType type, const TQString &filename, long line, const TQString& func) = 0;
 
     
     // Breakpoints
     virtual void showBreakpoint(const DebuggerBreakpoint &bp) = 0;
     virtual void refreshBreakpoints() = 0;
     virtual DebuggerBreakpoint * newDebuggerBreakpoint() = 0;
-    virtual DebuggerBreakpoint * findDebuggerBreakpoint(const QString& key) = 0;
-    virtual void updateBreakpointKey(const DebuggerBreakpoint &bp, const QString& newkey) = 0;
+    virtual DebuggerBreakpoint * findDebuggerBreakpoint(const TQString& key) = 0;
+    virtual void updateBreakpointKey(const DebuggerBreakpoint &bp, const TQString& newkey) = 0;
 
     // Path mapping
     virtual PathMapper* Mapper() = 0;
diff --git a/quanta/components/debugger/pathmapper.cpp b/quanta/components/debugger/pathmapper.cpp
index 194355d7..c38e2fec 100644
--- a/quanta/components/debugger/pathmapper.cpp
+++ b/quanta/components/debugger/pathmapper.cpp
@@ -23,12 +23,12 @@
 
 #include <kdebug.h>
 #include <klocale.h>
-#include <qstring.h>
+#include <tqstring.h>
 #include <qextfileinfo.h>
-#include <qdom.h>
+#include <tqdom.h>
 
-PathMapper::PathMapper(QObject *parent, const char *name)
-    : QObject(parent, name)
+PathMapper::PathMapper(TQObject *parent, const char *name)
+    : TQObject(parent, name)
 {
 
 }
@@ -38,9 +38,9 @@ PathMapper::PathMapper()
 
 }
 
-QString PathMapper::translate(const QString & path, const QString & from, const QString &to)
+TQString PathMapper::translate(const TQString & path, const TQString & from, const TQString &to)
 {
-  QString translated = path;
+  TQString translated = path;
   
   // Check if this dir is matched by the maps
   if(path.startsWith(from, false))
@@ -52,7 +52,7 @@ QString PathMapper::translate(const QString & path, const QString & from, const
   return translated;
 }
 
-QString PathMapper::mapLocalPathToServer(const QString &localpath)
+TQString PathMapper::mapLocalPathToServer(const TQString &localpath)
 {
   if(localpath.isEmpty())
     return localpath;
@@ -60,7 +60,7 @@ QString PathMapper::mapLocalPathToServer(const QString &localpath)
   if(m_localBasedir == "/" && m_serverBasedir == "/")
     return localpath;
     
-  QString newpath = translate(localpath, m_localBasedir, m_serverBasedir);
+  TQString newpath = translate(localpath, m_localBasedir, m_serverBasedir);
   
   // If no translation occurred, check and see if some of the other translations does
   if(newpath == localpath)
@@ -89,7 +89,7 @@ QString PathMapper::mapLocalPathToServer(const QString &localpath)
     for (unsigned int cnt = 0; cnt < m_serverlist.count(); cnt++ )
       pmdlg.addHistory(m_serverlist[cnt], m_locallist[cnt]);
 
-    if(pmdlg.exec() == QDialog::Accepted )
+    if(pmdlg.exec() == TQDialog::Accepted )
     {
       newpath = translate(localpath, pmdlg.localPath(), pmdlg.serverPath());
       addHistory(pmdlg.localPath(), pmdlg.serverPath(), newpath != localpath); 
@@ -101,9 +101,9 @@ QString PathMapper::mapLocalPathToServer(const QString &localpath)
   return newpath;
 }
 
-QString PathMapper::mapServerPathToLocal(const QString &serverpath)
+TQString PathMapper::mapServerPathToLocal(const TQString &serverpath)
 {
-  QString newpath;
+  TQString newpath;
   if(serverpath.isEmpty())
     return serverpath;
 
@@ -130,7 +130,7 @@ QString PathMapper::mapServerPathToLocal(const QString &serverpath)
     for (unsigned int cnt = 0; cnt < m_serverlist.count(); cnt++ )
       pmdlg.addHistory(m_serverlist[cnt], m_locallist[cnt]);
 
-    if(pmdlg.exec() == QDialog::Accepted )
+    if(pmdlg.exec() == TQDialog::Accepted )
     {
       addHistory(pmdlg.localPath(), pmdlg.serverPath(), true);
       newpath = translate(serverpath, pmdlg.localPath(), pmdlg.serverPath());
@@ -141,21 +141,21 @@ QString PathMapper::mapServerPathToLocal(const QString &serverpath)
   return serverpath;
 }
 
-void PathMapper::setLocalBasedir(const QString &localpath)
+void PathMapper::setLocalBasedir(const TQString &localpath)
 {
   m_localBasedir = localpath;
 }
-void PathMapper::setServerBasedir(const QString &serverpath)
+void PathMapper::setServerBasedir(const TQString &serverpath)
 {
   m_serverBasedir = serverpath;
 }
 
-QDomNode PathMapper::pathMapperNode()
+TQDomNode PathMapper::pathMapperNode()
 {
-  QDomNode nodeThisDbg;
-  QDomDocument *dom = Project::ref()->sessionDom();
-  QDomNode projectNode = dom->firstChild().firstChild();
-  QDomNode nodeDbg  = projectNode.namedItem("debuggers");
+  TQDomNode nodeThisDbg;
+  TQDomDocument *dom = Project::ref()->sessionDom();
+  TQDomNode projectNode = dom->firstChild().firstChild();
+  TQDomNode nodeDbg  = projectNode.namedItem("debuggers");
   if(nodeDbg.isNull())
   {
     nodeDbg = dom->createElement("debuggers");
@@ -173,7 +173,7 @@ QDomNode PathMapper::pathMapperNode()
   return nodeThisDbg;
 }
 
-void PathMapper::addHistory(const QString &localpath, const QString &serverpath, bool saveinproject)
+void PathMapper::addHistory(const TQString &localpath, const TQString &serverpath, bool saveinproject)
 {
   bool exists = false;
   for (unsigned int cnt = 0; cnt < m_serverlist.count() && !exists; cnt++ )
@@ -184,12 +184,12 @@ void PathMapper::addHistory(const QString &localpath, const QString &serverpath,
   {
     if(saveinproject)
     {
-      QDomNode node = pathMapperNode();
-      QDomNode newnode = Project::ref()->dom()->createElement("mapping");
+      TQDomNode node = pathMapperNode();
+      TQDomNode newnode = Project::ref()->dom()->createElement("mapping");
   
-      QDomAttr serverattr = Project::ref()->dom()->createAttribute("serverpath");
+      TQDomAttr serverattr = Project::ref()->dom()->createAttribute("serverpath");
       serverattr.setValue(serverpath);
-      QDomAttr localattr = Project::ref()->dom()->createAttribute("localpath");
+      TQDomAttr localattr = Project::ref()->dom()->createAttribute("localpath");
       localattr.setValue(localpath);
   
       newnode.attributes().setNamedItem(serverattr);
@@ -207,12 +207,12 @@ void PathMapper::addHistory(const QString &localpath, const QString &serverpath,
 
 void PathMapper::readConfig()
 {
-  QDomNode node = pathMapperNode();
+  TQDomNode node = pathMapperNode();
 
   // Server
-  QDomNode valuenode = node.namedItem("mappings");
-  QDomNode child = valuenode.firstChild();
-  QString serverpath, localpath;
+  TQDomNode valuenode = node.namedItem("mappings");
+  TQDomNode child = valuenode.firstChild();
+  TQString serverpath, localpath;
   while(!child.isNull())
   {
     serverpath = child.attributes().namedItem("serverpath").nodeValue();
diff --git a/quanta/components/debugger/pathmapper.h b/quanta/components/debugger/pathmapper.h
index b93b48cb..fd48e3ab 100644
--- a/quanta/components/debugger/pathmapper.h
+++ b/quanta/components/debugger/pathmapper.h
@@ -19,9 +19,9 @@
 #ifndef PATHMAPPER_H
 #define PATHMAPPER_H
 
-#include <qobject.h>
-#include <qdom.h>
-#include <qstringlist.h>
+#include <tqobject.h>
+#include <tqdom.h>
+#include <tqstringlist.h>
 
 class KURL;
 
@@ -30,26 +30,26 @@ class PathMapper : public QObject
     Q_OBJECT
 
   public:
-    PathMapper(QObject *parent = 0, const char *name = 0);
+    PathMapper(TQObject *parent = 0, const char *name = 0);
     PathMapper();
-    virtual QString mapLocalPathToServer(const QString &localpath);
-    virtual QString mapServerPathToLocal(const QString &serverpath);
+    virtual TQString mapLocalPathToServer(const TQString &localpath);
+    virtual TQString mapServerPathToLocal(const TQString &serverpath);
 
-    virtual void setLocalBasedir(const QString &localpath);
-    virtual void setServerBasedir(const QString &serverpath);
+    virtual void setLocalBasedir(const TQString &localpath);
+    virtual void setServerBasedir(const TQString &serverpath);
 
     void readConfig();
     
   private:
-    QDomNode pathMapperNode();
-    QString translate(const QString & path, const QString & from, const QString &to);
-    void addHistory(const QString &localpath, const QString &serverpath, bool saveinproject);
+    TQDomNode pathMapperNode();
+    TQString translate(const TQString & path, const TQString & from, const TQString &to);
+    void addHistory(const TQString &localpath, const TQString &serverpath, bool saveinproject);
     
-    QString m_localBasedir;
-    QString m_serverBasedir;
+    TQString m_localBasedir;
+    TQString m_serverBasedir;
 
-    QStringList m_serverlist;
-    QStringList m_locallist;
+    TQStringList m_serverlist;
+    TQStringList m_locallist;
 };
 
 #endif
diff --git a/quanta/components/debugger/pathmapperdialog.cpp b/quanta/components/debugger/pathmapperdialog.cpp
index 8cfb949e..74e01956 100644
--- a/quanta/components/debugger/pathmapperdialog.cpp
+++ b/quanta/components/debugger/pathmapperdialog.cpp
@@ -16,13 +16,13 @@
 
 
 #include "pathmapperdialog.h"
-#include <qlistview.h>
-#include <qlineedit.h>
+#include <tqlistview.h>
+#include <tqlineedit.h>
 #include <qextfileinfo.h>
-#include <qcolor.h>
+#include <tqcolor.h>
 #include <kled.h>
 
-PathMapperDialog::PathMapperDialog(const QString& path, const PathMapperDialog::Direction direction)
+PathMapperDialog::PathMapperDialog(const TQString& path, const PathMapperDialog::Direction direction)
     : PathMapperDialogS(0, "PathMapperDialog", false, 0)
 {
   m_direction = direction;
@@ -32,18 +32,18 @@ PathMapperDialog::PathMapperDialog(const QString& path, const PathMapperDialog::
   if(m_direction == LocalToServer)
     ledTranslationExists->hide();
   
-  connect(listHistory, SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
-  connect(lineLocalPath, SIGNAL(textChanged(const QString&)), this, SLOT(slotPathsChanged()));
-  connect(lineServerPath, SIGNAL(textChanged(const QString&)), this, SLOT(slotPathsChanged()));
+  connect(listHistory, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(slotSelectionChanged()));
+  connect(lineLocalPath, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotPathsChanged()));
+  connect(lineServerPath, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(slotPathsChanged()));
 }
 
 PathMapperDialog::~PathMapperDialog()
 {
 }
 
-void PathMapperDialog::addHistory(const QString &serverdir, const QString &localdir)
+void PathMapperDialog::addHistory(const TQString &serverdir, const TQString &localdir)
 {
-  new QListViewItem(listHistory, localdir, serverdir);
+  new TQListViewItem(listHistory, localdir, serverdir);
 }
 
 void PathMapperDialog::slotSelectionChanged()
@@ -54,7 +54,7 @@ void PathMapperDialog::slotSelectionChanged()
 
 void PathMapperDialog::slotPathsChanged()
 {
-  QString translated, from, to;
+  TQString translated, from, to;
   if(m_direction == ServerToLocal)
   {
     from = lineServerPath->text();
@@ -88,12 +88,12 @@ void PathMapperDialog::slotPathsChanged()
   lineTranslated->setText(translated);
 }
 
-QString PathMapperDialog::serverPath()
+TQString PathMapperDialog::serverPath()
 {
   return lineServerPath->text();
 }
 
-QString PathMapperDialog::localPath()
+TQString PathMapperDialog::localPath()
 {
   return lineLocalPath->text();
 }
diff --git a/quanta/components/debugger/pathmapperdialog.h b/quanta/components/debugger/pathmapperdialog.h
index 786de8ea..39eb4600 100644
--- a/quanta/components/debugger/pathmapperdialog.h
+++ b/quanta/components/debugger/pathmapperdialog.h
@@ -30,20 +30,20 @@ class PathMapperDialog : public PathMapperDialogS
       LocalToServer
     };
   
-    PathMapperDialog(const QString& path, const PathMapperDialog::Direction direction);
+    PathMapperDialog(const TQString& path, const PathMapperDialog::Direction direction);
     ~PathMapperDialog();
 
-    void addHistory(const QString &serverdir, const QString &localdir);
+    void addHistory(const TQString &serverdir, const TQString &localdir);
 
-    QString serverPath();
-    QString localPath();
+    TQString serverPath();
+    TQString localPath();
     
   public slots:
     void slotSelectionChanged();
     void slotPathsChanged();
   
   private:
-    QString m_path;
+    TQString m_path;
     Direction m_direction;
     
 };
diff --git a/quanta/components/debugger/quantadebuggerinterface.cpp b/quanta/components/debugger/quantadebuggerinterface.cpp
index bd9ba2e1..af70da0a 100644
--- a/quanta/components/debugger/quantadebuggerinterface.cpp
+++ b/quanta/components/debugger/quantadebuggerinterface.cpp
@@ -32,7 +32,7 @@
 
 class DebuggerBreakpoint;
 
-QuantaDebuggerInterface::QuantaDebuggerInterface (QObject *myparent, const char* name)
+QuantaDebuggerInterface::QuantaDebuggerInterface (TQObject *myparent, const char* name)
     : DebuggerInterface(myparent, name)
 {
   m_manager = static_cast<DebuggerManager*>(parent());
@@ -41,33 +41,33 @@ QuantaDebuggerInterface::QuantaDebuggerInterface (QObject *myparent, const char*
 QuantaDebuggerInterface::~QuantaDebuggerInterface ()
 {}
 
-void QuantaDebuggerInterface::haveBreakpoint (const QString& file, int line)
+void QuantaDebuggerInterface::haveBreakpoint (const TQString& file, int line)
 {
   return m_manager->haveBreakpoint(file, line);
 }
 
-void QuantaDebuggerInterface::havenoBreakpoint (const QString& file, int line)
+void QuantaDebuggerInterface::havenoBreakpoint (const TQString& file, int line)
 {
   return m_manager->havenoBreakpoint(file, line);
 }
 
 // Public help functions
-bool QuantaDebuggerInterface::showStatus(const QString& message, bool log)
+bool QuantaDebuggerInterface::showStatus(const TQString& message, bool log)
 {
   return m_manager->showStatus(message, log);
 }
 
-bool QuantaDebuggerInterface::setActiveLine(const QString& file, int line)
+bool QuantaDebuggerInterface::setActiveLine(const TQString& file, int line)
 {
   return m_manager->setActiveLine(file, line);
 }
 
-void QuantaDebuggerInterface::enableAction(const QString& action, bool enable)
+void QuantaDebuggerInterface::enableAction(const TQString& action, bool enable)
 {
   m_manager->enableAction(action, enable);
 }
 
-void QuantaDebuggerInterface::fileOpened(const QString& file)
+void QuantaDebuggerInterface::fileOpened(const TQString& file)
 {
   m_manager->fileOpened(file);
 }
@@ -77,9 +77,9 @@ void QuantaDebuggerInterface::sendRequest(const KURL &url)
   m_manager->UI()->sendRequest(url);
 }
 
-const QString QuantaDebuggerInterface::activeFileParts(const QString & str)
+const TQString QuantaDebuggerInterface::activeFileParts(const TQString & str)
 {
-  QString newstr = str;
+  TQString newstr = str;
 
   // a/r = absolute/relative
   // f/p/d = file/project/docroot
@@ -111,12 +111,12 @@ void QuantaDebuggerInterface::showVariable(DebuggerVariable* var)
   m_manager->UI()->addVariable(var);
 }
 
-DebuggerVariable *QuantaDebuggerInterface::newDebuggerVariable(const QString& name, const QString& value, int type)
+DebuggerVariable *QuantaDebuggerInterface::newDebuggerVariable(const TQString& name, const TQString& value, int type)
 {
   return new DebuggerVariable(name, value, type);
 }
 
-DebuggerVariable *QuantaDebuggerInterface::newDebuggerVariable(const QString& name, const ValueList_t& values, int type)
+DebuggerVariable *QuantaDebuggerInterface::newDebuggerVariable(const TQString& name, const ValueList_t& values, int type)
 {
   return new DebuggerVariable(name, values, type);
 }
@@ -136,7 +136,7 @@ DebuggerBreakpoint *QuantaDebuggerInterface::newDebuggerBreakpoint()
   return new DebuggerBreakpoint();
 }
 
-DebuggerBreakpoint *QuantaDebuggerInterface::findDebuggerBreakpoint(const QString& key)
+DebuggerBreakpoint *QuantaDebuggerInterface::findDebuggerBreakpoint(const TQString& key)
 {
   return m_manager->findDebuggerBreakpoint(key);
 }
@@ -158,7 +158,7 @@ PathMapper* QuantaDebuggerInterface::Mapper()
   return m_manager->Mapper();
 }
 
-void QuantaDebuggerInterface::updateBreakpointKey( const DebuggerBreakpoint & bp, const QString & newkey )
+void QuantaDebuggerInterface::updateBreakpointKey( const DebuggerBreakpoint & bp, const TQString & newkey )
 {
   m_manager->updateBreakpointKey(bp, newkey);
 }
@@ -168,7 +168,7 @@ void QuantaDebuggerInterface::backtraceClear( )
   m_manager->UI()->backtraceClear();
 }
 
-void QuantaDebuggerInterface::backtraceShow( long level, BacktraceType type, const QString & filename, long line, const QString & func )
+void QuantaDebuggerInterface::backtraceShow( long level, BacktraceType type, const TQString & filename, long line, const TQString & func )
 {
   m_manager->UI()->backtraceShow(level, type, filename, line, func);
 }
diff --git a/quanta/components/debugger/quantadebuggerinterface.h b/quanta/components/debugger/quantadebuggerinterface.h
index 44be8f4a..d18fd1cd 100644
--- a/quanta/components/debugger/quantadebuggerinterface.h
+++ b/quanta/components/debugger/quantadebuggerinterface.h
@@ -18,8 +18,8 @@
 #ifndef MYDEBUGMANAGER_H
 #define MYDEBUGMANAGER_H
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 #include "debuggerinterface.h"
 #include "debuggervariable.h"
 
@@ -33,39 +33,39 @@ class QuantaDebuggerInterface : public DebuggerInterface
     DebuggerManager *m_manager;
 
   public:
-    QuantaDebuggerInterface(QObject *myparent, const char* name);
+    QuantaDebuggerInterface(TQObject *myparent, const char* name);
     ~QuantaDebuggerInterface();
 
     // Breakpoints
-    void haveBreakpoint (const QString& file, int line) ;
-    void havenoBreakpoint (const QString& file, int line) ;
+    void haveBreakpoint (const TQString& file, int line) ;
+    void havenoBreakpoint (const TQString& file, int line) ;
     void refreshBreakpoints();
 
     // Public help functions
-    bool showStatus(const QString& message, bool log);
-    bool setActiveLine (const QString& file, int line) ;
+    bool showStatus(const TQString& message, bool log);
+    bool setActiveLine (const TQString& file, int line) ;
 
-    void enableAction(const QString& action, bool enable);
-    void fileOpened(const QString& file) ;
+    void enableAction(const TQString& action, bool enable);
+    void fileOpened(const TQString& file) ;
     void sendRequest(const KURL &url);
-    virtual const QString activeFileParts(const QString & str);
+    virtual const TQString activeFileParts(const TQString & str);
 
     // Watches handling
     //void preWatchUpdate();
     //void postWatchUpdate();
-    DebuggerVariable* newDebuggerVariable(const QString& name, const QString& value, int type);
-    DebuggerVariable* newDebuggerVariable(const QString& name, const ValueList_t& values, int type);
+    DebuggerVariable* newDebuggerVariable(const TQString& name, const TQString& value, int type);
+    DebuggerVariable* newDebuggerVariable(const TQString& name, const ValueList_t& values, int type);
     void showVariable(DebuggerVariable*);
 
     // Breakpoints
     void showBreakpoint(const DebuggerBreakpoint &bp);
     DebuggerBreakpoint * newDebuggerBreakpoint();
-    DebuggerBreakpoint * findDebuggerBreakpoint(const QString& key);
-    void updateBreakpointKey(const DebuggerBreakpoint &bp, const QString& newkey);
+    DebuggerBreakpoint * findDebuggerBreakpoint(const TQString& key);
+    void updateBreakpointKey(const DebuggerBreakpoint &bp, const TQString& newkey);
 
     // Backtrace
     void backtraceClear();
-    void backtraceShow(long level, BacktraceType type, const QString &filename, long line, const QString& func);
+    void backtraceShow(long level, BacktraceType type, const TQString &filename, long line, const TQString& func);
 
     // Path mapping
     PathMapper* Mapper();
diff --git a/quanta/components/debugger/variableslistview.cpp b/quanta/components/debugger/variableslistview.cpp
index c9d77de3..03ddd7d3 100644
--- a/quanta/components/debugger/variableslistview.cpp
+++ b/quanta/components/debugger/variableslistview.cpp
@@ -21,7 +21,7 @@
 #include <kiconloader.h>
 #include <kdeversion.h>
 #include <kinputdialog.h>
-#include <qclipboard.h>
+#include <tqclipboard.h>
 
 // Quanta includes
 #include "variableslistview.h"
@@ -47,12 +47,12 @@ namespace VariablesListViewColumns
   };
 }
 
-VariablesListView::VariablesListView(QWidget *parent, const char *name)
+VariablesListView::VariablesListView(TQWidget *parent, const char *name)
     : KListView(parent, name)
 {
   // If you change here, change the VariablesListViewColumns enums above
   addColumn(i18n("Name"));
-  addColumn(QString::null);
+  addColumn(TQString::null);
   addColumn(i18n("Value"));
   addColumn(i18n("Type"));
   addColumn(i18n("Size"));
@@ -60,16 +60,16 @@ VariablesListView::VariablesListView(QWidget *parent, const char *name)
   setSorting(-1); // No sorting
   
   m_variablePopup = new KPopupMenu(this);
-  m_variablePopup->insertItem(SmallIcon("editdelete"), i18n("&Remove"), this, SLOT(slotRemoveSelected()), 0, removeWatch);
+  m_variablePopup->insertItem(SmallIcon("editdelete"), i18n("&Remove"), this, TQT_SLOT(slotRemoveSelected()), 0, removeWatch);
 
   if(quantaApp->debugger()->client()->supports(DebuggerClientCapabilities::VariableSetValue))
-    m_variablePopup->insertItem(SmallIcon("edit"), i18n("&Set Value"), this, SLOT(slotVariableSetValue()), 0, setValue);
+    m_variablePopup->insertItem(SmallIcon("edit"), i18n("&Set Value"), this, TQT_SLOT(slotVariableSetValue()), 0, setValue);
 
-  m_variablePopup->insertItem(SmallIcon("viewmag"), i18n("&Dump in Messages Log"), this, SLOT(slotVariableDump()), 0, dumpValue);
+  m_variablePopup->insertItem(SmallIcon("viewmag"), i18n("&Dump in Messages Log"), this, TQT_SLOT(slotVariableDump()), 0, dumpValue);
   
-  m_variablePopup->insertItem(SmallIcon("editcopy"), i18n("&Copy to Clipboard"), this, SLOT(slotVariableCopyToClipboard()), 0, copyValue);
+  m_variablePopup->insertItem(SmallIcon("editcopy"), i18n("&Copy to Clipboard"), this, TQT_SLOT(slotVariableCopyToClipboard()), 0, copyValue);
 
-  connect(this, SIGNAL( contextMenu( KListView *, QListViewItem *, const QPoint & ) ), this, SLOT(slotVariableContextMenu(KListView *, QListViewItem *, const QPoint &)));
+  connect(this, TQT_SIGNAL( contextMenu( KListView *, TQListViewItem *, const TQPoint & ) ), this, TQT_SLOT(slotVariableContextMenu(KListView *, TQListViewItem *, const TQPoint &)));
 }
 
 
@@ -104,7 +104,7 @@ void VariablesListView::slotRemoveSelected()
   delete v;
 }
 
-void VariablesListView::keyPressEvent(QKeyEvent *e)
+void VariablesListView::keyPressEvent(TQKeyEvent *e)
 {
   if(e->key() != Qt::Key_Delete)
   {
@@ -161,11 +161,11 @@ void VariablesListView::replaceVariable(DebuggerVariable* oldvar, DebuggerVariab
   KListViewItem * item;
   
   // Remove children that doesen't exist anymore
-  QPtrList<DebuggerVariable> oldlist = oldvar->values();
+  TQPtrList<DebuggerVariable> oldlist = oldvar->values();
   for(DebuggerVariable* oldchild = oldlist.last(); oldchild; oldchild = oldlist.prev())
   {
     bool found = false;
-    QPtrList<DebuggerVariable> newlist = newvar->values();
+    TQPtrList<DebuggerVariable> newlist = newvar->values();
     for(DebuggerVariable* newchild = newlist.last(); newchild; newchild = newlist.prev())
     {
       if(newchild->name() == oldchild->name())
@@ -179,11 +179,11 @@ void VariablesListView::replaceVariable(DebuggerVariable* oldvar, DebuggerVariab
   }
 
   // Update and add children
-  QPtrList<DebuggerVariable> newlist = newvar->values();
+  TQPtrList<DebuggerVariable> newlist = newvar->values();
   for(DebuggerVariable* newchild = newlist.last(); newchild; newchild = newlist.prev())
   {
     bool found = false;
-    QPtrList<DebuggerVariable> oldlist = oldvar->values();
+    TQPtrList<DebuggerVariable> oldlist = oldvar->values();
     for(DebuggerVariable* oldchild = oldlist.last(); oldchild; oldchild = oldlist.prev())  
     {
       if(newchild->name() == oldchild->name())
@@ -215,11 +215,11 @@ void VariablesListView::replaceVariable(DebuggerVariable* oldvar, DebuggerVariab
   item->setText(VariablesListViewColumns::Name, oldvar->name());
   item->setText(VariablesListViewColumns::Type, oldvar->typeName());
   item->setText(VariablesListViewColumns::Size, oldvar->sizeName());
-  item->setText(VariablesListViewColumns::Value, (newvar->isScalar() ? oldvar->value() : QString()));
+  item->setText(VariablesListViewColumns::Value, (newvar->isScalar() ? oldvar->value() : TQString()));
   
 }
 
-void VariablesListView::slotVariableContextMenu(KListView *, QListViewItem *, const QPoint& point)
+void VariablesListView::slotVariableContextMenu(KListView *, TQListViewItem *, const TQPoint& point)
 {
   if(!selectedItem())
     return;
@@ -242,7 +242,7 @@ void VariablesListView::slotVariableSetValue()
 
   DebuggerVariable v(selected());
 
-  QString newvalue;
+  TQString newvalue;
   switch(v.type())
   {
     case DebuggerVariableTypes::String:
@@ -284,7 +284,7 @@ void VariablesListView::slotVariableCopyToClipboard( )
   DebuggerVariable *v = selected(true);
   if(!v)
     return;
-  QApplication::clipboard()->setText(v->value());
+  TQApplication::clipboard()->setText(v->value());
 }
 
 #include "variableslistview.moc"
diff --git a/quanta/components/debugger/variableslistview.h b/quanta/components/debugger/variableslistview.h
index 41de5328..729aa8d8 100644
--- a/quanta/components/debugger/variableslistview.h
+++ b/quanta/components/debugger/variableslistview.h
@@ -21,7 +21,7 @@
 
 #include <klistview.h>
 #include <kpopupmenu.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
 class DebuggerVariable;
 
@@ -38,7 +38,7 @@ class VariablesListView : public KListView
   };
       
   public:
-    VariablesListView(QWidget *parent = 0, const char *name = 0);
+    VariablesListView(TQWidget *parent = 0, const char *name = 0);
     ~VariablesListView();
 
     void addVariable(DebuggerVariable* variable);
@@ -54,17 +54,17 @@ class VariablesListView : public KListView
     void slotVariableSetValue();
     void slotVariableDump();
     void slotVariableCopyToClipboard();
-    void slotVariableContextMenu(KListView *list, QListViewItem * item, const QPoint& point);
+    void slotVariableContextMenu(KListView *list, TQListViewItem * item, const TQPoint& point);
 
   signals:
     void valueChanged(DebuggerVariable*);
     void removeVariable(DebuggerVariable*);
 
   private:
-    void keyPressEvent(QKeyEvent *e);
+    void keyPressEvent(TQKeyEvent *e);
     void replaceVariable(DebuggerVariable* oldvar, DebuggerVariable* newvar);
 
-    QPtrList<DebuggerVariable> m_variablesList;
+    TQPtrList<DebuggerVariable> m_variablesList;
     KPopupMenu *m_variablePopup;
 };