Trinity Qt initial conversion

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

1 files changed, 105 insertions, 105 deletions

diff --git a/languages/ruby/debugger/rdbcontroller.cpp b/languages/ruby/debugger/rdbcontroller.cpp
index 160754a0..f0b6ea40 100644
--- a/languages/ruby/debugger/rdbcontroller.cpp
+++ b/languages/ruby/debugger/rdbcontroller.cpp
@@ -45,11 +45,11 @@
 #include <kmessagebox.h>
 #include <kprocess.h>
 
-#include <qdatetime.h>
-#include <qfileinfo.h>
-#include <qregexp.h>
-#include <qstring.h>
-#include <qtextstream.h>
+#include <tqdatetime.h>
+#include <tqfileinfo.h>
+#include <tqregexp.h>
+#include <tqstring.h>
+#include <tqtextstream.h>
 
 #include <iostream>
 #include <ctype.h>
@@ -89,10 +89,10 @@ int debug_controllerExists = false;
 
 // At the moment a Unix domain socket is used. It might be better to
 // change to tcp/ip and listen on a port instead
-QCString RDBController::unixSocketPath_;
+TQCString RDBController::unixSocketPath_;
 
 
-RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack, QDomDocument &projectDom)
+RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack, TQDomDocument &projectDom)
         : DbgController(),
         frameStack_(frameStack),
         varTree_(varTree),
@@ -129,9 +129,9 @@ RDBController::RDBController(VariableTree *varTree, FramestackWidget *frameStack
 	strcpy(sockaddr.sun_path, unixSocketPath_);
 	bind(masterSocket_, (const struct sockaddr*) &sockaddr, sizeof(sockaddr));
 	listen(masterSocket_, 1);
-	acceptNotifier_ = new QSocketNotifier(masterSocket_, QSocketNotifier::Read, this);
-    QObject::connect( acceptNotifier_, SIGNAL(activated(int)),
-                          this, SLOT(slotAcceptConnection(int)) );	
+	acceptNotifier_ = new TQSocketNotifier(masterSocket_, TQSocketNotifier::Read, this);
+    TQObject::connect( acceptNotifier_, TQT_SIGNAL(activated(int)),
+                          this, TQT_SLOT(slotAcceptConnection(int)) );	
 						  	
     configure();
     cmdList_.setAutoDelete(true);
@@ -153,7 +153,7 @@ RDBController::~RDBController()
     delete[] rdbOutput_;
     debug_controllerExists = false;
 
-	QFileInfo unixSocket(unixSocketPath_);
+	TQFileInfo unixSocket(unixSocketPath_);
 	if (unixSocket.exists()) {
 		unlink(unixSocketPath_);
 	}
@@ -231,7 +231,7 @@ void RDBController::executeCmd()
         setStateOff(s_appNotStarted|s_programExited|s_silent);
     }
 
-    QString prettyCmd = currentCmd_->cmdToSend();
+    TQString prettyCmd = currentCmd_->cmdToSend();
     prettyCmd = currentPrompt_ + prettyCmd;
     emit rdbStdout( prettyCmd.latin1() );
 	
@@ -291,7 +291,7 @@ void RDBController::pauseApp()
 
 // Whenever the program pauses we need to refresh the data visible to
 // the user. The reason we've stopped may be passed in  to be emitted.
-void RDBController::actOnProgramPause(const QString &msg)
+void RDBController::actOnProgramPause(const TQString &msg)
 {
     // We're only stopping if we were running, of course.
     if (stateIsOn(s_appBusy))
@@ -326,7 +326,7 @@ void RDBController::actOnProgramPause(const QString &msg)
 // an invalid program specified or ...
 // rdb is still running though, but only the run command (may) make sense
 // all other commands are disabled.
-void RDBController::programNoApp(const QString &msg, bool msgBox)
+void RDBController::programNoApp(const TQString &msg, bool msgBox)
 {
     state_ = (s_appNotStarted|s_programExited|(state_&(s_shuttingDown)));
     destroyCmds();
@@ -358,17 +358,17 @@ void RDBController::programNoApp(const QString &msg, bool msgBox)
 // The data gets parsed here and emitted in its component parts.
 void RDBController::parseProgramLocation(char *buf)
 {
-	QString buffer(buf);
-	QString line;
-	QTextStream input(&buffer, IO_ReadOnly);
-	QString sourceFile;
+	TQString buffer(buf);
+	TQString line;
+	TQTextStream input(&buffer, IO_ReadOnly);
+	TQString sourceFile;
 	int sourceLine = 0;
 	
     //  "1: a = 1"
-    QRegExp display_re("^(\\d+):\\s(.*)$");
+    TQRegExp display_re("^(\\d+):\\s(.*)$");
 	
     //  "/opt/qt/src/widgets/qlistview.rb:1558:puts 'hello world'"
-    QRegExp sourcepos_re("^([^:]+):(\\d+):");
+    TQRegExp sourcepos_re("^([^:]+):(\\d+):");
 		
 	line = input.readLine();
 	while (! line.isNull()) {
@@ -388,7 +388,7 @@ void RDBController::parseProgramLocation(char *buf)
 						&& !sourceFile.endsWith("/korundum.rb") ) )
 		&& !sourceFile.endsWith("/debuggee.rb") ) 
 	{
-        actOnProgramPause(QString());
+        actOnProgramPause(TQString());
         emit showStepInSource(sourceFile, sourceLine, "");
 		return;
 	}
@@ -422,7 +422,7 @@ void RDBController::parseSwitchThread(char *buf)
 {
 	// Look for the thread number
 	// 2 #<Thread:0x30091998 sleep>   /home/duke/play/testit/trykorundum/src/bar.rb:13
-    QRegExp thread_re("(\\d+)");
+    TQRegExp thread_re("(\\d+)");
 	if (thread_re.search(buf) != -1) {
 		viewedThread_ = thread_re.cap(1).toInt();
 		currentFrame_ = 1;
@@ -434,7 +434,7 @@ void RDBController::parseSwitchThread(char *buf)
 // After an 'up nnn' or 'down nnn' command, get the new source file and line no.
 void RDBController::parseFrameMove(char *buf)
 {
-	QString sourceFile;
+	TQString sourceFile;
 	int sourceLine = 0;
 	
     if (stateIsOn(s_fetchLocals)) {
@@ -442,7 +442,7 @@ void RDBController::parseFrameMove(char *buf)
 	}
 	
 	// "#2 /home/duke/play/testit/trykorundum/src/main.rb:11"
-    QRegExp sourcepos_re("#\\d+\\s([^:]+):(\\d+)");
+    TQRegExp sourcepos_re("#\\d+\\s([^:]+):(\\d+)");
 	if (sourcepos_re.search(buf) != -1) {
 		sourceFile = sourcepos_re.cap(1);
 		sourceLine = sourcepos_re.cap(2).toInt();
@@ -505,7 +505,7 @@ void RDBController::parseFrameSelected(char *buf)
 {
     if (!stateIsOn(s_silent)) {
         emit showStepInSource("", -1, "");
-        emit dbgStatus (i18n("No source: %1").arg(QString(buf)), state_);
+        emit dbgStatus (i18n("No source: %1").arg(TQString(buf)), state_);
     }
 }
 
@@ -527,7 +527,7 @@ void RDBController::parseUpdateDisplay(char *buf)
 {
 	varTree_->viewport()->setUpdatesEnabled(false);
 	
-    QRegExp display_re("(\\d+):\\s([^\n]*)\n");
+    TQRegExp display_re("(\\d+):\\s([^\n]*)\n");
 	
 	int pos = display_re.search(buf);
 	while (pos != -1) {
@@ -644,14 +644,14 @@ void RDBController::parse(char *buf)
 
 // **************************************************************************
 
-void RDBController::setBreakpoint(const QCString &BPSetCmd, int key)
+void RDBController::setBreakpoint(const TQCString &BPSetCmd, int key)
 {
     queueCmd(new RDBSetBreakpointCommand(BPSetCmd, key));
 }
 
 // **************************************************************************
 
-void RDBController::clearBreakpoint(const QCString &BPClearCmd)
+void RDBController::clearBreakpoint(const TQCString &BPClearCmd)
 {
     queueCmd(new RDBCommand(BPClearCmd, NOTRUNCMD, NOTINFOCMD));
     // Note: this is NOT an info command, because rdb doesn't explictly tell
@@ -668,7 +668,7 @@ void RDBController::modifyBreakpoint( const Breakpoint& BP )
     if (BP.dbgId() > 0)
     {
         if (BP.changedEnable())
-            queueCmd(new RDBCommand(QCString().sprintf("%s %d",
+            queueCmd(new RDBCommand(TQCString().sprintf("%s %d",
                             BP.isEnabled() ? "enable" : "disable",
                             BP.dbgId()), NOTRUNCMD, NOTINFOCMD));
 
@@ -688,7 +688,7 @@ void RDBController::modifyBreakpoint( const Breakpoint& BP )
 
 // **************************************************************************
 
-void RDBController::slotStart(const QString& ruby_interpreter, const QString& character_coding, const QString& run_directory, const QString& debuggee_path, const QString &application, const QString& run_arguments, bool show_constants, bool trace_into_ruby)
+void RDBController::slotStart(const TQString& ruby_interpreter, const TQString& character_coding, const TQString& run_directory, const TQString& debuggee_path, const TQString &application, const TQString& run_arguments, bool show_constants, bool trace_into_ruby)
 {
     Q_ASSERT (!dbgProcess_ && !tty_);
 	
@@ -696,11 +696,11 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
     tty_ = new STTY(config_dbgTerminal_, Settings::terminalEmulatorName( *kapp->config() ));
     if (!config_dbgTerminal_)
     {
-        connect( tty_, SIGNAL(OutOutput(const char*)), SIGNAL(ttyStdout(const char*)) );
-        connect( tty_, SIGNAL(ErrOutput(const char*)), SIGNAL(ttyStderr(const char*)) );
+        connect( tty_, TQT_SIGNAL(OutOutput(const char*)), TQT_SIGNAL(ttyStdout(const char*)) );
+        connect( tty_, TQT_SIGNAL(ErrOutput(const char*)), TQT_SIGNAL(ttyStderr(const char*)) );
     }
 
-    QString tty(tty_->getSlave());
+    TQString tty(tty_->getSlave());
     if (tty.isEmpty())
     {
         KMessageBox::error(0, i18n("The ruby debugger cannot use the tty* or pty* devices.\n"
@@ -716,17 +716,17 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 
     dbgProcess_ = new KProcess;
 
-    connect( dbgProcess_, SIGNAL(receivedStdout(KProcess *, char *, int)),
-             this,        SLOT(slotDbgStdout(KProcess *, char *, int)) );
+    connect( dbgProcess_, TQT_SIGNAL(receivedStdout(KProcess *, char *, int)),
+             this,        TQT_SLOT(slotDbgStdout(KProcess *, char *, int)) );
 
-    connect( dbgProcess_, SIGNAL(receivedStderr(KProcess *, char *, int)),
-             this,        SLOT(slotDbgStderr(KProcess *, char *, int)) );
+    connect( dbgProcess_, TQT_SIGNAL(receivedStderr(KProcess *, char *, int)),
+             this,        TQT_SLOT(slotDbgStderr(KProcess *, char *, int)) );
 
-    connect( dbgProcess_, SIGNAL(wroteStdin(KProcess *)),
-             this,        SLOT(slotDbgWroteStdin(KProcess *)) );
+    connect( dbgProcess_, TQT_SIGNAL(wroteStdin(KProcess *)),
+             this,        TQT_SLOT(slotDbgWroteStdin(KProcess *)) );
 
-    connect( dbgProcess_, SIGNAL(processExited(KProcess*)),
-             this,        SLOT(slotDbgProcessExited(KProcess*)) );
+    connect( dbgProcess_, TQT_SIGNAL(processExited(KProcess*)),
+             this,        TQT_SLOT(slotDbgProcessExited(KProcess*)) );
 
 	rubyInterpreter_ = ruby_interpreter;
 	characterCoding_ = character_coding;
@@ -739,7 +739,7 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 
 	*dbgProcess_ << ruby_interpreter;
 	*dbgProcess_ << character_coding;
-	*dbgProcess_ << "-C" << QString(QFile::encodeName( run_directory ));
+	*dbgProcess_ << "-C" << TQString(TQFile::encodeName( run_directory ));
 	*dbgProcess_ << "-r" << debuggee_path;
 	*dbgProcess_ << application;
 	
@@ -747,8 +747,8 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
 		*dbgProcess_ << run_arguments;
 	}
 
-    emit rdbStdout(QString( ruby_interpreter + " " + character_coding
-							+ " -C " + QString(QFile::encodeName( run_directory ))
+    emit rdbStdout(TQString( ruby_interpreter + " " + character_coding
+							+ " -C " + TQString(TQFile::encodeName( run_directory ))
 							+ " -r " + debuggee_path + " " 
 							+ application + " " + run_arguments ).latin1() );
 
@@ -766,9 +766,9 @@ void RDBController::slotStart(const QString& ruby_interpreter, const QString& ch
     // BUT the app hasn't been started yet! A run command is about to be issued
     // by whoever is controlling us.
 	
-    if (!dbgProcess_->writeStdin(QString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
+    if (!dbgProcess_->writeStdin(TQString("%1\n").arg(unixSocketPath_).latin1(), strlen(unixSocketPath_) + 1)) {
         kdDebug(9012) << "failed to write Unix domain socket path to rdb " 
-		<< QString("%1\n").arg(unixSocketPath_).latin1() << endl;
+		<< TQString("%1\n").arg(unixSocketPath_).latin1() << endl;
 	}
 	
 	setStateOff(s_programExited);
@@ -785,8 +785,8 @@ void RDBController::slotStopDebugger()
     setStateOn(s_shuttingDown|s_silent);
     destroyCmds();
 
-    QTime start;
-    QTime now;
+    TQTime start;
+    TQTime now;
 
     // Get rdb's attention if it's busy. We need rdb to be at the
     // command line so we can stop it.
@@ -794,11 +794,11 @@ void RDBController::slotStopDebugger()
     {
         kdDebug(9012) << "ruby debugger busy on shutdown - stopping rdb (SIGINT)" << endl;
         dbgProcess_->kill(SIGINT);
-        start = QTime::currentTime();
+        start = TQTime::currentTime();
         while (-1)
         {
             kapp->processEvents(20);
-            now = QTime::currentTime();
+            now = TQTime::currentTime();
             if (!stateIsOn(s_appBusy) || start.msecsTo( now ) > 2000)
                 break;
         }
@@ -813,11 +813,11 @@ void RDBController::slotStopDebugger()
         kdDebug(9012) << "failed to write 'quit' to ruby debugger" << endl;
 
     emit rdbStdout("(rdb:1) quit");
-    start = QTime::currentTime();
+    start = TQTime::currentTime();
     while (-1)
     {
          kapp->processEvents(20);
-         now = QTime::currentTime();
+         now = TQTime::currentTime();
          if (stateIsOn(s_programExited) || start.msecsTo( now ) > 2000)
              break;
     }
@@ -858,17 +858,17 @@ void RDBController::slotRun()
 
 // **************************************************************************
 
-void RDBController::slotRunUntil(const QString &fileName, int lineNum)
+void RDBController::slotRunUntil(const TQString &fileName, int lineNum)
 {
     if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (fileName.isEmpty())
-        queueCmd(new RDBCommand( QCString().sprintf("break %d", lineNum),
+        queueCmd(new RDBCommand( TQCString().sprintf("break %d", lineNum),
                                 RUNCMD, NOTINFOCMD));
     else
         queueCmd(new RDBCommand(
-                QCString().sprintf("break %s:%d", fileName.latin1(), lineNum),
+                TQCString().sprintf("break %s:%d", fileName.latin1(), lineNum),
                                 RUNCMD, NOTINFOCMD));
     queueCmd(new RDBCommand("cont", RUNCMD, NOTINFOCMD));
 								
@@ -1014,7 +1014,7 @@ void RDBController::slotClearAllBreakpoints()
 
 // **************************************************************************
 
-void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& frameName)
+void RDBController::slotSelectFrame(int frameNo, int threadNo, const TQString& frameName)
 {
 	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown)) {
 		kdDebug(9012) << "RDBController::slotSelectFrame wrong state" << endl;
@@ -1023,19 +1023,19 @@ void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& fr
 
 	if (viewedThread_ != threadNo) {
 		// Note that 'thread switch nnn' is a run command
-		queueCmd(new RDBCommand(QCString().sprintf("thread switch %d",
+		queueCmd(new RDBCommand(TQCString().sprintf("thread switch %d",
                                 threadNo), RUNCMD, INFOCMD));
 		executeCmd();
 		return;
 	}
 		
 	if (frameNo > currentFrame_) {
-    	queueCmd(new RDBCommand(QCString().sprintf("up %d", frameNo - currentFrame_), NOTRUNCMD, INFOCMD));
+    	queueCmd(new RDBCommand(TQCString().sprintf("up %d", frameNo - currentFrame_), NOTRUNCMD, INFOCMD));
 		if (!stateIsOn(s_fetchLocals)) {
         	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
 		}
 	} else if (frameNo < currentFrame_) {
-    	queueCmd(new RDBCommand(QCString().sprintf("down %d", currentFrame_ - frameNo), NOTRUNCMD, INFOCMD));
+    	queueCmd(new RDBCommand(TQCString().sprintf("down %d", currentFrame_ - frameNo), NOTRUNCMD, INFOCMD));
 		if (!stateIsOn(s_fetchLocals)) {
         	queueCmd(new RDBCommand("display", NOTRUNCMD, INFOCMD));
 		}
@@ -1080,7 +1080,7 @@ void RDBController::slotSelectFrame(int frameNo, int threadNo, const QString& fr
 // **************************************************************************
 
 // This is called when an item needs special processing to show a value.
-void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
+void RDBController::slotExpandItem(VarItem *item, const TQCString &userRequest)
 {
 	if (stateIsOn(s_appBusy|s_dbgNotStarted|s_shuttingDown))
         return;
@@ -1091,7 +1091,7 @@ void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
     if (userRequest.isEmpty())
         return;
 
-    queueCmd(new RDBItemCommand(item, QCString("pp ") + userRequest.data(), false));
+    queueCmd(new RDBItemCommand(item, TQCString("pp ") + userRequest.data(), false));
 	
 	if (currentCmd_ == 0) {
 		executeCmd();
@@ -1101,9 +1101,9 @@ void RDBController::slotExpandItem(VarItem *item, const QCString &userRequest)
 // **************************************************************************
 
 // This method evaluates text selected with the 'Inspect:' context menu
-void RDBController::slotRubyInspect(const QString &inspectText)
+void RDBController::slotRubyInspect(const TQString &inspectText)
 {
-    queueCmd(new RDBCommand(	QCString().sprintf("p %s", inspectText.latin1()), 
+    queueCmd(new RDBCommand(	TQCString().sprintf("p %s", inspectText.latin1()), 
 								NOTRUNCMD, 
 								INFOCMD ), true );
 	executeCmd();
@@ -1113,9 +1113,9 @@ void RDBController::slotRubyInspect(const QString &inspectText)
 // **************************************************************************
 
 // Add a new expression to be displayed in the Watch variable tree
-void RDBController::slotAddWatchExpression(const QString& expr, bool execute)
+void RDBController::slotAddWatchExpression(const TQString& expr, bool execute)
 {
-	queueCmd(new RDBCommand(	QCString().sprintf("display %s", expr.latin1()), 
+	queueCmd(new RDBCommand(	TQCString().sprintf("display %s", expr.latin1()), 
 								NOTRUNCMD, 
 								NOTINFOCMD ) );
 	if (execute) {
@@ -1128,7 +1128,7 @@ void RDBController::slotAddWatchExpression(const QString& expr, bool execute)
 // Add a new expression to be displayed in the Watch variable tree
 void RDBController::slotRemoveWatchExpression(int displayId)
 {
-    queueCmd(new RDBCommand(	QCString().sprintf("undisplay %d", displayId), 
+    queueCmd(new RDBCommand(	TQCString().sprintf("undisplay %d", displayId), 
 								NOTRUNCMD, 
 								INFOCMD ) );
 	executeCmd();
@@ -1156,7 +1156,7 @@ void RDBController::slotFetchGlobals(bool fetch)
 // Data from the ruby program's stdout gets processed here.
 void RDBController::slotDbgStdout(KProcess *, char *buf, int buflen)
 {
-    QCString msg(buf, buflen+1);
+    TQCString msg(buf, buflen+1);
     emit ttyStdout(msg);
 }
 
@@ -1165,7 +1165,7 @@ void RDBController::slotDbgStdout(KProcess *, char *buf, int buflen)
 // Data from the ruby program's stderr gets processed here.
 void RDBController::slotDbgStderr(KProcess *, char *buf, int buflen)
 {
-    QCString msg(buf, buflen+1);
+    TQCString msg(buf, buflen+1);
     emit ttyStderr(msg);
 }
 
@@ -1198,9 +1198,9 @@ void RDBController::slotAcceptConnection(int masterSocket)
     	kdDebug(9012) << "RDBController::slotAcceptConnection can't set nonblocking socket " << errno << endl;
 	}
 	
-	socketNotifier_ = new QSocketNotifier(socket_, QSocketNotifier::Read, 0);
-    QObject::connect( socketNotifier_, SIGNAL(activated(int)),
-                          this, SLOT(slotReadFromSocket(int)) );	
+	socketNotifier_ = new TQSocketNotifier(socket_, TQSocketNotifier::Read, 0);
+    TQObject::connect( socketNotifier_, TQT_SIGNAL(activated(int)),
+                          this, TQT_SLOT(slotReadFromSocket(int)) );	
     
 	setStateOff(s_dbgNotStarted);
     emit dbgStatus ("", state_);
@@ -1245,7 +1245,7 @@ void RDBController::slotReadFromSocket(int socket)
 
 //    kdDebug(9012) << "RDBController::slotReadFromSocket length: " << rdbOutputLen_ << " input: " << rdbOutput_ << endl;
 	
-	QRegExp prompt_re("(\\(rdb:(\\d+)\\) )$");
+	TQRegExp prompt_re("(\\(rdb:(\\d+)\\) )$");
  	int promptPos = prompt_re.search(rdbOutput_, 0);
 	
 	// Keep appending output to the rbdOutput_ buffer until the
@@ -1303,54 +1303,54 @@ void RDBController::slotDbgProcessExited(KProcess*)
 
 // Takes abbreviated commands and expands them, before passing them on to rdb
 //
-void RDBController::slotUserRDBCmd(const QString& cmd)
+void RDBController::slotUserRDBCmd(const TQString& cmd)
 {
     kdDebug(9012) << "Requested user cmd: " << cmd << endl;
-    QRegExp break_re("^b(reak)?(\\s.*)?");
-    QRegExp watch_re("^wat(ch)?\\s+(.*)");
-    QRegExp delete_re("^del(ete)?(\\s.*)?");
-    QRegExp display_re("^disp(lay)?(\\s.*)?");
-    QRegExp undisplay_re("^undisp(lay)?(\\s.*)?");
-    QRegExp step_re("^s(tep)?(\\s[\\d]+)?$");
-    QRegExp next_re("^n(ext)?(\\s[\\d]+)?$");
-    QRegExp varlocal_re("^v(ar)?\\s+l(ocal)?");
-    QRegExp varglobal_re("^v(ar)?\\s+g(lobal)?");
-    QRegExp varinstance_re("^v(ar)?\\s+i(nstance)?\\s(.*)");
-    QRegExp varconst_re("^v(ar)?\\s+c(onst)?\\s(.*)");
-    QRegExp threadlist_re("^th(read)?\\s+l(ist)?");
-    QRegExp threadcurrent_re("^th(read)?(\\sc(ur(rent)?)?)?$");
-    QRegExp threadswitch_re("^th(read)?(\\ssw(itch)?)?(\\s.*)");
-    QRegExp thread_re("^th(read)?(\\s+.*)?");
-    QRegExp methodinstance_re("^m(ethod)?\\s+i(nstance)?\\s+(.*)");
-    QRegExp method_re("^m(ethod)?\\s+(.*)");
-    QRegExp list_re("^l(ist)?(\\s+\\d+-\\d+)?$");
+    TQRegExp break_re("^b(reak)?(\\s.*)?");
+    TQRegExp watch_re("^wat(ch)?\\s+(.*)");
+    TQRegExp delete_re("^del(ete)?(\\s.*)?");
+    TQRegExp display_re("^disp(lay)?(\\s.*)?");
+    TQRegExp undisplay_re("^undisp(lay)?(\\s.*)?");
+    TQRegExp step_re("^s(tep)?(\\s[\\d]+)?$");
+    TQRegExp next_re("^n(ext)?(\\s[\\d]+)?$");
+    TQRegExp varlocal_re("^v(ar)?\\s+l(ocal)?");
+    TQRegExp varglobal_re("^v(ar)?\\s+g(lobal)?");
+    TQRegExp varinstance_re("^v(ar)?\\s+i(nstance)?\\s(.*)");
+    TQRegExp varconst_re("^v(ar)?\\s+c(onst)?\\s(.*)");
+    TQRegExp threadlist_re("^th(read)?\\s+l(ist)?");
+    TQRegExp threadcurrent_re("^th(read)?(\\sc(ur(rent)?)?)?$");
+    TQRegExp threadswitch_re("^th(read)?(\\ssw(itch)?)?(\\s.*)");
+    TQRegExp thread_re("^th(read)?(\\s+.*)?");
+    TQRegExp methodinstance_re("^m(ethod)?\\s+i(nstance)?\\s+(.*)");
+    TQRegExp method_re("^m(ethod)?\\s+(.*)");
+    TQRegExp list_re("^l(ist)?(\\s+\\d+-\\d+)?$");
     
     if ( break_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("break%s", break_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("break%s", break_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( watch_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("watch %s", watch_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("watch %s", watch_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( delete_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("delete%s", delete_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("delete%s", delete_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( display_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("display%s", display_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("display%s", display_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( undisplay_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("undisplay%s", undisplay_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("undisplay%s", undisplay_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( step_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("step%s", step_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("step%s", step_re.cap(2).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( next_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("next%s", next_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("next%s", next_re.cap(2).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( varlocal_re.search(cmd) >= 0 ) {
@@ -1358,23 +1358,23 @@ void RDBController::slotUserRDBCmd(const QString& cmd)
     } else if ( varglobal_re.search(cmd) >= 0 ) {
         queueCmd(new RDBCommand("var global", NOTRUNCMD, INFOCMD));
     } else if ( varinstance_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("var instance %s", varinstance_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("var instance %s", varinstance_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( varconst_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("var const %s", varconst_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("var const %s", varconst_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( methodinstance_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("method instance %s", methodinstance_re.cap(3).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("method instance %s", methodinstance_re.cap(3).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( method_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("method %s", method_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("method %s", method_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if ( list_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("list%s", list_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("list%s", list_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
 	} else if (cmd == "c" || cmd == "cont") {
@@ -1386,11 +1386,11 @@ void RDBController::slotUserRDBCmd(const QString& cmd)
     } else if ( threadcurrent_re.search(cmd) >= 0 ) {
         queueCmd(new RDBCommand("thread current", NOTRUNCMD, INFOCMD), true );
     } else if ( threadswitch_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("thread switch%s", threadswitch_re.cap(4).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("thread switch%s", threadswitch_re.cap(4).latin1()), 
 									RUNCMD, 
 									INFOCMD ), true );
     } else if ( thread_re.search(cmd) >= 0 ) {
-        queueCmd(new RDBCommand(	QCString().sprintf("thread%s", thread_re.cap(2).latin1()), 
+        queueCmd(new RDBCommand(	TQCString().sprintf("thread%s", thread_re.cap(2).latin1()), 
 									NOTRUNCMD, 
 									INFOCMD ), true );
     } else if (cmd == "frame" || cmd == "f" || cmd == "where" || cmd == "w") {