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, 125 insertions, 125 deletions

diff --git a/languages/ruby/debugger/debuggerpart.cpp b/languages/ruby/debugger/debuggerpart.cpp
index 95b4dd09..3e46a3d4 100644
--- a/languages/ruby/debugger/debuggerpart.cpp
+++ b/languages/ruby/debugger/debuggerpart.cpp
@@ -18,10 +18,10 @@
  ***************************************************************************/
 #include "debuggerpart.h"
 
-#include <qdir.h>
-#include <qvbox.h>
-#include <qwhatsthis.h>
-#include <qpopupmenu.h>
+#include <tqdir.h>
+#include <tqvbox.h>
+#include <tqwhatsthis.h>
+#include <tqpopupmenu.h>
 
 #include <kaction.h>
 #include <kdebug.h>
@@ -36,7 +36,7 @@
 #include <kmessagebox.h>
 #include <kapplication.h>
 #include <dcopclient.h>
-#include <qtimer.h>
+#include <tqtimer.h>
 #include <kstringhandler.h>
 #include <kstandarddirs.h>
 
@@ -72,7 +72,7 @@ static const KDevPluginInfo data("kdevrbdebugger");
 typedef KDevGenericFactory<RubyDebuggerPart> RubyDebuggerFactory;
 K_EXPORT_COMPONENT_FACTORY( libkdevrbdebugger, RubyDebuggerFactory( data ) )
 
-RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QStringList & ) :
+RubyDebuggerPart::RubyDebuggerPart( TQObject *parent, const char *name, const TQStringList & ) :
     KDevPlugin( &data, parent, name ? name : "RubyDebuggerPart" ),
     controller(0)
 {
@@ -83,7 +83,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
     m_debugger = new Debugger( partController() );
     
-	statusBarIndicator = new QLabel(" ", mainWindow()->statusBar());
+	statusBarIndicator = new TQLabel(" ", mainWindow()->statusBar());
     statusBarIndicator->setFixedWidth(15);
     mainWindow()->statusBar()->addWidget(statusBarIndicator, 0, true);
     statusBarIndicator->show();
@@ -93,7 +93,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 //     /*variableWidget*/->setEnabled(false);
     variableWidget->setIcon(SmallIcon("math_brace"));
     variableWidget->setCaption(i18n("Variable Tree"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (variableWidget, i18n("<b>Variable tree</b><p>"
                               "The variable tree allows you to see "
                               "the variable values as you step "
@@ -108,7 +108,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
     rdbBreakpointWidget = new RDBBreakpointWidget( 0, "rdbBreakpointWidget" );
     rdbBreakpointWidget->setCaption(i18n("Breakpoint List"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (rdbBreakpointWidget, i18n("<b>Breakpoint list</b><p>"
                                 "Displays a list of breakpoints with "
                                 "their current status. Clicking on a "
@@ -121,7 +121,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     framestackWidget = new FramestackWidget( 0, "rdbFramestackWidget" );
     framestackWidget->setEnabled(false);
     framestackWidget->setCaption(i18n("Frame Stack"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (framestackWidget, i18n("<b>Frame stack</b><p>"
                                 "Often referred to as the \"call stack\", "
                                 "this is a list showing what method is "
@@ -139,7 +139,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     rdbOutputWidget->setEnabled(false);
     rdbOutputWidget->setIcon( SmallIcon("inline_image") );
     rdbOutputWidget->setCaption(i18n("RDB Output"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (rdbOutputWidget, i18n("<b>RDB output</b><p>"
                                  "Shows all rdb commands being executed. "
                                  "You can also issue any other rdb command while debugging."));
@@ -148,19 +148,19 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
     mainWindow()->setViewAvailable(rdbOutputWidget, false);
 
     // rdbBreakpointWidget -> this
-    connect( rdbBreakpointWidget, SIGNAL(refreshBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( rdbBreakpointWidget, SIGNAL(publishBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( rdbBreakpointWidget, SIGNAL(gotoSourcePosition(const QString&, int)),
-             this,             SLOT(slotGotoSource(const QString&, int)) );
+    connect( rdbBreakpointWidget, TQT_SIGNAL(refreshBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( rdbBreakpointWidget, TQT_SIGNAL(publishBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( rdbBreakpointWidget, TQT_SIGNAL(gotoSourcePosition(const TQString&, int)),
+             this,             TQT_SLOT(slotGotoSource(const TQString&, int)) );
 
     // Now setup the actions
     KAction *action;
 
 //    action = new KAction(i18n("&Start"), "1rightarrow", CTRL+SHIFT+Key_F9,
     action = new KAction(i18n("&Start"), "dbgrun", CTRL+SHIFT+Key_F9,
-                         this, SLOT(slotRun()),
+                         this, TQT_SLOT(slotRun()),
                          actionCollection(), "debug_run");
     action->setToolTip( i18n("Start in debugger") );
     action->setWhatsThis( i18n("<b>Start in debugger</b><p>"
@@ -171,26 +171,26 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
                                "about variables, frame stack, and so on.") );
 
     action = new KAction(i18n("Sto&p"), "stop", 0,
-                         this, SLOT(slotStop()),
+                         this, TQT_SLOT(slotStop()),
                          actionCollection(), "debug_stop");
     action->setToolTip( i18n("Stop debugger") );
     action->setWhatsThis(i18n("<b>Stop debugger</b><p>Kills the executable and exits the debugger."));
 
     action = new KAction(i18n("Interrupt"), "player_pause", 0,
-                         this, SLOT(slotPause()),
+                         this, TQT_SLOT(slotPause()),
                          actionCollection(), "debug_pause");
     action->setToolTip( i18n("Interrupt application") );
     action->setWhatsThis(i18n("<b>Interrupt application</b><p>Interrupts the debugged process or current RDB command."));
 
     action = new KAction(i18n("Run to &Cursor"), "dbgrunto", 0,
-                         this, SLOT(slotRunToCursor()),
+                         this, TQT_SLOT(slotRunToCursor()),
                          actionCollection(), "debug_runtocursor");
     action->setToolTip( i18n("Run to cursor") );
     action->setWhatsThis(i18n("<b>Run to cursor</b><p>Continues execution until the cursor position is reached."));
 
 
     action = new KAction(i18n("Step &Over"), "dbgnext", 0,
-                         this, SLOT(slotStepOver()),
+                         this, TQT_SLOT(slotStepOver()),
                          actionCollection(), "debug_stepover");
     action->setToolTip( i18n("Step over the next line") );
     action->setWhatsThis( i18n("<b>Step over</b><p>"
@@ -201,7 +201,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Step &Into"), "dbgstep", 0,
-                         this, SLOT(slotStepInto()),
+                         this, TQT_SLOT(slotStepInto()),
                          actionCollection(), "debug_stepinto");
     action->setToolTip( i18n("Step into the next statement") );
     action->setWhatsThis( i18n("<b>Step into</b><p>"
@@ -212,7 +212,7 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Step O&ut"), "dbgstepout", 0,
-                         this, SLOT(slotStepOut()),
+                         this, TQT_SLOT(slotStepOut()),
                          actionCollection(), "debug_stepout");
     action->setToolTip( i18n("Steps out of the current method") );
     action->setWhatsThis( i18n("<b>Step out</b><p>"
@@ -224,48 +224,48 @@ RubyDebuggerPart::RubyDebuggerPart( QObject *parent, const char *name, const QSt
 
 
     action = new KAction(i18n("Toggle Breakpoint"), 0, 0,
-                         this, SLOT(toggleBreakpoint()),
+                         this, TQT_SLOT(toggleBreakpoint()),
                          actionCollection(), "debug_toggle_breakpoint");
     action->setToolTip(i18n("Toggle breakpoint"));
     action->setWhatsThis(i18n("<b>Toggle breakpoint</b><p>Toggles the breakpoint at the current line in editor."));
 
-    connect( mainWindow()->main()->guiFactory(), SIGNAL(clientAdded(KXMLGUIClient*)),
-             this, SLOT(guiClientAdded(KXMLGUIClient*)) );
+    connect( mainWindow()->main()->guiFactory(), TQT_SIGNAL(clientAdded(KXMLGUIClient*)),
+             this, TQT_SLOT(guiClientAdded(KXMLGUIClient*)) );
 
 
-    connect( partController(), SIGNAL(loadedFile(const KURL &)),
-             rdbBreakpointWidget, SLOT(slotRefreshBP(const KURL &)) );
-    connect( debugger(), SIGNAL(toggledBreakpoint(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotToggleBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(editedBreakpoint(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotEditBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(toggledBreakpointEnabled(const QString &, int)),
-             rdbBreakpointWidget, SLOT(slotToggleBreakpointEnabled(const QString &, int)) );
+    connect( partController(), TQT_SIGNAL(loadedFile(const KURL &)),
+             rdbBreakpointWidget, TQT_SLOT(slotRefreshBP(const KURL &)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpoint(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotToggleBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(editedBreakpoint(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotEditBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpointEnabled(const TQString &, int)),
+             rdbBreakpointWidget, TQT_SLOT(slotToggleBreakpointEnabled(const TQString &, int)) );
 
-    connect( core(), SIGNAL(contextMenu(QPopupMenu *, const Context *)),
-             this, SLOT(contextMenu(QPopupMenu *, const Context *)) );
+    connect( core(), TQT_SIGNAL(contextMenu(TQPopupMenu *, const Context *)),
+             this, TQT_SLOT(contextMenu(TQPopupMenu *, const Context *)) );
 
-    connect( core(), SIGNAL(stopButtonClicked(KDevPlugin*)),
-             this, SLOT(slotStop(KDevPlugin*)) );
-    connect( core(), SIGNAL(projectClosed()),
-             this, SLOT(projectClosed()) );
+    connect( core(), TQT_SIGNAL(stopButtonClicked(KDevPlugin*)),
+             this, TQT_SLOT(slotStop(KDevPlugin*)) );
+    connect( core(), TQT_SIGNAL(projectClosed()),
+             this, TQT_SLOT(projectClosed()) );
 
-    connect( partController(), SIGNAL(activePartChanged(KParts::Part*)),
-             this, SLOT(slotActivePartChanged(KParts::Part*)) );
+    connect( partController(), TQT_SIGNAL(activePartChanged(KParts::Part*)),
+             this, TQT_SLOT(slotActivePartChanged(KParts::Part*)) );
 
     procLineMaker = new ProcessLineMaker();
 
-    connect( procLineMaker, SIGNAL(receivedStdoutLine(const QCString&)),
-             appFrontend(), SLOT(insertStdoutLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedStderrLine(const QCString&)),
-             appFrontend(), SLOT(insertStderrLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedPartialStdoutLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStdoutLine(const QCString&)) );
-    connect( procLineMaker, SIGNAL(receivedPartialStderrLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStderrLine(const QCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedStdoutLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(insertStdoutLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedStderrLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(insertStderrLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedPartialStdoutLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(addPartialStdoutLine(const TQCString&)) );
+    connect( procLineMaker, TQT_SIGNAL(receivedPartialStderrLine(const TQCString&)),
+             appFrontend(), TQT_SLOT(addPartialStderrLine(const TQCString&)) );
 
     setupController();
-    QTimer::singleShot(0, this, SLOT(setupDcop()));
+    TQTimer::singleShot(0, this, TQT_SLOT(setupDcop()));
 }
 
 RubyDebuggerPart::~RubyDebuggerPart()
@@ -297,10 +297,10 @@ void RubyDebuggerPart::guiClientAdded( KXMLGUIClient* client )
     // Can't change state until after XMLGUI has been loaded...
     // Anyone know of a better way of doing this?
     if( client == this )
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
 }
 
-void RubyDebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
+void RubyDebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
 {
     if (!context->hasType( Context::EditorContext ))
         return;
@@ -311,16 +311,16 @@ void RubyDebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
     popup->insertSeparator();
     if (econtext->url().isLocalFile())
     {
-        int id = popup->insertItem( i18n("Toggle Breakpoint"), this, SLOT(toggleBreakpoint()) );
+        int id = popup->insertItem( i18n("Toggle Breakpoint"), this, TQT_SLOT(toggleBreakpoint()) );
         popup->setWhatsThis(id, i18n("<b>Toggle breakpoint</b><p>Toggles breakpoint at the current line."));
     }
     if (!m_contextIdent.isEmpty())
     {
-        QString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
-        int id = popup->insertItem( i18n("Watch: %1").arg(squeezed), this, SLOT(contextWatch()) );
+        TQString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
+        int id = popup->insertItem( i18n("Watch: %1").arg(squeezed), this, TQT_SLOT(contextWatch()) );
         popup->setWhatsThis(id, i18n("<b>Watch</b><p>Adds an expression under the cursor to the Variables/Watch list."));
         
-		id = popup->insertItem( i18n("Inspect: %1").arg(squeezed), this, SLOT(contextRubyInspect()) );
+		id = popup->insertItem( i18n("Inspect: %1").arg(squeezed), this, TQT_SLOT(contextRubyInspect()) );
         popup->setWhatsThis(id, i18n("<b>Inspect</b><p>Evaluates an expression under the cursor."));
     }
 }
@@ -362,86 +362,86 @@ void RubyDebuggerPart::setupController()
     controller = new RDBController(variableTree, framestackWidget, *projectDom());
 
     // this -> controller
-    connect( this,                  SIGNAL(rubyInspect(const QString&)),
-             controller,            SLOT(slotRubyInspect(const QString&)));
+    connect( this,                  TQT_SIGNAL(rubyInspect(const TQString&)),
+             controller,            TQT_SLOT(slotRubyInspect(const TQString&)));
 
     // variableTree -> framestackWidget
-    connect( variableTree,          SIGNAL(selectFrame(int, int)),
-             framestackWidget,      SLOT(slotSelectFrame(int, int)));
+    connect( variableTree,          TQT_SIGNAL(selectFrame(int, int)),
+             framestackWidget,      TQT_SLOT(slotSelectFrame(int, int)));
     
 	// framestackWidget -> variableTree
-    connect( framestackWidget,      SIGNAL(frameActive(int, int, const QString&)),
-             variableTree,          SLOT(slotFrameActive(int, int, const QString&)));
+    connect( framestackWidget,      TQT_SIGNAL(frameActive(int, int, const TQString&)),
+             variableTree,          TQT_SLOT(slotFrameActive(int, int, const TQString&)));
 	
     // variableTree -> controller
-    connect( variableTree,          SIGNAL(expandItem(VarItem*, const QCString&)),
-             controller,            SLOT(slotExpandItem(VarItem*, const QCString&)));
-    connect( variableTree,          SIGNAL(fetchGlobals(bool)),
-             controller,            SLOT(slotFetchGlobals(bool)));
-    connect( variableTree,          SIGNAL(addWatchExpression(const QString&, bool)),
-             controller,            SLOT(slotAddWatchExpression(const QString&, bool)));  
-    connect( variableTree,          SIGNAL(removeWatchExpression(int)),
-             controller,            SLOT(slotRemoveWatchExpression(int)));  
+    connect( variableTree,          TQT_SIGNAL(expandItem(VarItem*, const TQCString&)),
+             controller,            TQT_SLOT(slotExpandItem(VarItem*, const TQCString&)));
+    connect( variableTree,          TQT_SIGNAL(fetchGlobals(bool)),
+             controller,            TQT_SLOT(slotFetchGlobals(bool)));
+    connect( variableTree,          TQT_SIGNAL(addWatchExpression(const TQString&, bool)),
+             controller,            TQT_SLOT(slotAddWatchExpression(const TQString&, bool)));  
+    connect( variableTree,          TQT_SIGNAL(removeWatchExpression(int)),
+             controller,            TQT_SLOT(slotRemoveWatchExpression(int)));  
     
     // framestackWidget -> controller
-    connect( framestackWidget,      SIGNAL(selectFrame(int,int,const QString&)),
-             controller,            SLOT(slotSelectFrame(int,int,const QString&)));
+    connect( framestackWidget,      TQT_SIGNAL(selectFrame(int,int,const TQString&)),
+             controller,            TQT_SLOT(slotSelectFrame(int,int,const TQString&)));
 
     // rdbBreakpointWidget -> controller
-    connect( rdbBreakpointWidget,   SIGNAL(clearAllBreakpoints()),
-             controller,            SLOT(slotClearAllBreakpoints()));
-    connect( rdbBreakpointWidget,   SIGNAL(publishBPState(const Breakpoint&)),
-             controller,            SLOT(slotBPState(const Breakpoint &)));
+    connect( rdbBreakpointWidget,   TQT_SIGNAL(clearAllBreakpoints()),
+             controller,            TQT_SLOT(slotClearAllBreakpoints()));
+    connect( rdbBreakpointWidget,   TQT_SIGNAL(publishBPState(const Breakpoint&)),
+             controller,            TQT_SLOT(slotBPState(const Breakpoint &)));
 
 
     // rdbOutputWidget -> controller
-    connect( rdbOutputWidget,       SIGNAL(userRDBCmd(const QString &)),
-             controller,            SLOT(slotUserRDBCmd(const QString&)));
-    connect( rdbOutputWidget,       SIGNAL(breakInto()),
-             controller,            SLOT(slotBreakInto()));
+    connect( rdbOutputWidget,       TQT_SIGNAL(userRDBCmd(const TQString &)),
+             controller,            TQT_SLOT(slotUserRDBCmd(const TQString&)));
+    connect( rdbOutputWidget,       TQT_SIGNAL(breakInto()),
+             controller,            TQT_SLOT(slotBreakInto()));
 
     // controller -> rdbBreakpointWidget
-    connect( controller,            SIGNAL(acceptPendingBPs()),
-             rdbBreakpointWidget,   SLOT(slotSetPendingBPs()));
-    connect( controller,            SIGNAL(unableToSetBPNow(int)),
-             rdbBreakpointWidget,   SLOT(slotUnableToSetBPNow(int)));
-    connect( controller,            SIGNAL(rawRDBBreakpointList (char*)),
-             rdbBreakpointWidget,   SLOT(slotParseRDBBrkptList(char*)));
-    connect( controller,            SIGNAL(rawRDBBreakpointSet(char*, int)),
-             rdbBreakpointWidget,   SLOT(slotParseRDBBreakpointSet(char*, int)));
+    connect( controller,            TQT_SIGNAL(acceptPendingBPs()),
+             rdbBreakpointWidget,   TQT_SLOT(slotSetPendingBPs()));
+    connect( controller,            TQT_SIGNAL(unableToSetBPNow(int)),
+             rdbBreakpointWidget,   TQT_SLOT(slotUnableToSetBPNow(int)));
+    connect( controller,            TQT_SIGNAL(rawRDBBreakpointList (char*)),
+             rdbBreakpointWidget,   TQT_SLOT(slotParseRDBBrkptList(char*)));
+    connect( controller,            TQT_SIGNAL(rawRDBBreakpointSet(char*, int)),
+             rdbBreakpointWidget,   TQT_SLOT(slotParseRDBBreakpointSet(char*, int)));
 
 
     // controller -> this
-    connect( controller,            SIGNAL(dbgStatus(const QString&, int)),
-             this,                  SLOT(slotStatus(const QString&, int)));
-    connect( controller,            SIGNAL(showStepInSource(const QString&, int, const QString&)),
-             this,                  SLOT(slotShowStep(const QString&, int)));
+    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
+             this,                  TQT_SLOT(slotStatus(const TQString&, int)));
+    connect( controller,            TQT_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
+             this,                  TQT_SLOT(slotShowStep(const TQString&, int)));
 
     // controller -> procLineMaker
-    connect( controller,            SIGNAL(ttyStdout(const char*)),
-             procLineMaker,         SLOT(slotReceivedStdout(const char*)));
-    connect( controller,            SIGNAL(ttyStderr(const char*)),
-             procLineMaker,         SLOT(slotReceivedStderr(const char*)));
+    connect( controller,            TQT_SIGNAL(ttyStdout(const char*)),
+             procLineMaker,         TQT_SLOT(slotReceivedStdout(const char*)));
+    connect( controller,            TQT_SIGNAL(ttyStderr(const char*)),
+             procLineMaker,         TQT_SLOT(slotReceivedStderr(const char*)));
 
     // controller -> rdbOutputWidget
-    connect( controller,            SIGNAL(rdbStdout(const char*)),
-             rdbOutputWidget,       SLOT(slotReceivedStdout(const char*)) );
-    connect( controller,            SIGNAL(rdbStderr(const char*)),
-             rdbOutputWidget,       SLOT(slotReceivedStderr(const char*)) );
-    connect( controller,            SIGNAL(dbgStatus(const QString&, int)),
-             rdbOutputWidget,       SLOT(slotDbgStatus(const QString&, int)));
+    connect( controller,            TQT_SIGNAL(rdbStdout(const char*)),
+             rdbOutputWidget,       TQT_SLOT(slotReceivedStdout(const char*)) );
+    connect( controller,            TQT_SIGNAL(rdbStderr(const char*)),
+             rdbOutputWidget,       TQT_SLOT(slotReceivedStderr(const char*)) );
+    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
+             rdbOutputWidget,       TQT_SLOT(slotDbgStatus(const TQString&, int)));
 
 }
 
 
 bool RubyDebuggerPart::startDebugger()
 {
-    QString build_dir;              // Currently selected build directory
-    QString run_directory;          // Directory from where the program should be run
-    QString program;                // Absolute path to application
-    QString run_arguments;          // Command line arguments to be passed to the application
-    QString ruby_interpreter;       // Absolute path to the ruby interpreter
-    QString debuggee_path;          // Absolute path to debuggee.rb debugger script
+    TQString build_dir;              // Currently selected build directory
+    TQString run_directory;          // Directory from where the program should be run
+    TQString program;                // Absolute path to application
+    TQString run_arguments;          // Command line arguments to be passed to the application
+    TQString ruby_interpreter;       // Absolute path to the ruby interpreter
+    TQString debuggee_path;          // Absolute path to debuggee.rb debugger script
     bool show_constants;            // Show constants in the debugger
     bool trace_into_ruby;           // Trace into the ruby code installed under sitedir
 
@@ -465,10 +465,10 @@ bool RubyDebuggerPart::startDebugger()
 	
     run_arguments = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/programargs");
 
-    QString shell = DomUtil::readEntry(*projectDom(), "/kdevrbdebugger/general/dbgshell");
+    TQString shell = DomUtil::readEntry(*projectDom(), "/kdevrbdebugger/general/dbgshell");
     if( !shell.isEmpty() )
     {
-        QFileInfo info( shell );
+        TQFileInfo info( shell );
         if( info.isRelative() )
         {
             shell = build_dir + "/" + shell;
@@ -486,7 +486,7 @@ bool RubyDebuggerPart::startDebugger()
 
     core()->running(this, true);
 
-    stateChanged( QString("active") );
+    stateChanged( TQString("active") );
 
     KActionCollection *ac = actionCollection();
     ac->action("debug_run")->setText( i18n("&Continue") );
@@ -518,7 +518,7 @@ bool RubyDebuggerPart::startDebugger()
 	ruby_interpreter = DomUtil::readEntry(*projectDom(), "/kdevrubysupport/run/interpreter");
     
 	int coding = DomUtil::readIntEntry(*projectDom(), "/kdevrubysupport/run/charactercoding");
-	QString character_coding("-K");
+	TQString character_coding("-K");
 	
 	switch (coding) {
 	case 0:
@@ -535,7 +535,7 @@ bool RubyDebuggerPart::startDebugger()
 		break;
 	}
 	
-//	ruby_interpreter.append(QString(" -K") + code);
+//	ruby_interpreter.append(TQString(" -K") + code);
 	
 	debuggee_path = ::locate("data", "kdevrbdebugger/debuggee.rb", instance());
 
@@ -577,7 +577,7 @@ void RubyDebuggerPart::slotStopDebugger()
                                            "while it is running, in order to get information "
                                            "about variables, frame stack, and so on.") );
 
-    stateChanged( QString("stopped") );
+    stateChanged( TQString("stopped") );
 
     core()->running(this, false);
 }
@@ -683,9 +683,9 @@ void RubyDebuggerPart::slotRefreshBPState( const Breakpoint& BP)
 }
 
 
-void RubyDebuggerPart::slotStatus(const QString &msg, int state)
+void RubyDebuggerPart::slotStatus(const TQString &msg, int state)
 {
-    QString stateIndicator;
+    TQString stateIndicator;
 
     if (state & s_dbgNotStarted)
     {
@@ -695,12 +695,12 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
     {
         stateIndicator = "A";
         debugger()->clearExecutionPoint();
-        stateChanged( QString("active") );
+        stateChanged( TQString("active") );
     }
     else if (state & s_programExited)
     {
         stateIndicator = "E";
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
         KActionCollection *ac = actionCollection();
         ac->action("debug_run")->setText( i18n("Restart") );
 //        ac->action("debug_run")->setIcon( "1rightarrow" );
@@ -712,7 +712,7 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
     else
     {
         stateIndicator = "P";
-        stateChanged( QString("paused") );
+        stateChanged( TQString("paused") );
     }
 
     // And now? :-)
@@ -725,7 +725,7 @@ void RubyDebuggerPart::slotStatus(const QString &msg, int state)
 }
 
 
-void RubyDebuggerPart::slotShowStep(const QString &fileName, int lineNum)
+void RubyDebuggerPart::slotShowStep(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
     {
@@ -735,7 +735,7 @@ void RubyDebuggerPart::slotShowStep(const QString &fileName, int lineNum)
 }
 
 
-void RubyDebuggerPart::slotGotoSource(const QString &fileName, int lineNum)
+void RubyDebuggerPart::slotGotoSource(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
         partController()->editDocument(KURL( fileName ), lineNum);
@@ -758,13 +758,13 @@ void RubyDebuggerPart::slotActivePartChanged( KParts::Part* part )
     action->setEnabled( iface != 0 );
 }
 
-void RubyDebuggerPart::restorePartialProjectSession(const QDomElement* el)
+void RubyDebuggerPart::restorePartialProjectSession(const TQDomElement* el)
 {
     rdbBreakpointWidget->restorePartialProjectSession(el);
 	variableWidget->restorePartialProjectSession(el);
 }
 
-void RubyDebuggerPart::savePartialProjectSession(QDomElement* el)
+void RubyDebuggerPart::savePartialProjectSession(TQDomElement* el)
 {
     rdbBreakpointWidget->savePartialProjectSession(el);
 	variableWidget->savePartialProjectSession(el);