Trinity Qt initial conversion

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

8 files changed, 144 insertions, 144 deletions

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);