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

diff --git a/languages/cpp/debugger/debuggerpart.cpp b/languages/cpp/debugger/debuggerpart.cpp
index c8c3c1a1..4842ca84 100644
--- a/languages/cpp/debugger/debuggerpart.cpp
+++ b/languages/cpp/debugger/debuggerpart.cpp
@@ -14,11 +14,11 @@
 #include "debuggerpart.h"
 #include "label_with_double_click.h"
 
-#include <qdir.h>
-#include <qvbox.h>
-#include <qwhatsthis.h>
-#include <qpopupmenu.h>
-#include <qtooltip.h>
+#include <tqdir.h>
+#include <tqvbox.h>
+#include <tqwhatsthis.h>
+#include <tqpopupmenu.h>
+#include <tqtooltip.h>
 
 #include <kaction.h>
 #include <kdebug.h>
@@ -33,7 +33,7 @@
 #include <kmessagebox.h>
 #include <kapplication.h>
 #include <dcopclient.h>
-#include <qtimer.h>
+#include <tqtimer.h>
 #include <kstringhandler.h>
 #include <kdockwidget.h>
 
@@ -76,7 +76,7 @@ static const KDevPluginInfo data("kdevdebugger");
 typedef KDevGenericFactory<DebuggerPart> DebuggerFactory;
 K_EXPORT_COMPONENT_FACTORY( libkdevdebugger, DebuggerFactory( data ) )
 
-DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList & ) :
+DebuggerPart::DebuggerPart( TQObject *parent, const char *name, const TQStringList & ) :
     KDevPlugin( &data, parent, name ? name : "DebuggerPart" ),
     controller(0), previousDebuggerState_(s_dbgNotStarted),
     justRestarted_(false), needRebuild_(true),
@@ -104,7 +104,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
     gdbBreakpointWidget = new GDBBreakpointWidget( controller,
                                                    0, "gdbBreakpointWidget" );
     gdbBreakpointWidget->setCaption(i18n("Breakpoint List"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (gdbBreakpointWidget, i18n("<b>Breakpoint list</b><p>"
                                 "Displays a list of breakpoints with "
                                 "their current status. Clicking on a "
@@ -124,7 +124,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
     framestackWidget = new FramestackWidget( controller, 0, "framestackWidget" );
     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 function is "
@@ -140,7 +140,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
     disassembleWidget = new DisassembleWidget( controller, 0, "disassembleWidget" );
     disassembleWidget->setEnabled(false);
     disassembleWidget->setCaption(i18n("Machine Code Display"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (disassembleWidget, i18n("<b>Machine code display</b><p>"
                                  "A machine code view into your running "
                                  "executable with the current instruction "
@@ -157,7 +157,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
     gdbOutputWidget->setEnabled(false);
     gdbOutputWidget->setIcon( SmallIcon("inline_image") );
     gdbOutputWidget->setCaption(i18n("GDB Output"));
-    QWhatsThis::add
+    TQWhatsThis::add
         (gdbOutputWidget, i18n("<b>GDB output</b><p>"
                                  "Shows all gdb commands being executed. "
                                  "You can also issue any other gdb command while debugging."));
@@ -166,12 +166,12 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
     mainWindow()->setViewAvailable(gdbOutputWidget, false);
 
     // gdbBreakpointWidget -> this
-    connect( gdbBreakpointWidget, SIGNAL(refreshBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( gdbBreakpointWidget, SIGNAL(publishBPState(const Breakpoint&)),
-             this,             SLOT(slotRefreshBPState(const Breakpoint&)));
-    connect( gdbBreakpointWidget, SIGNAL(gotoSourcePosition(const QString&, int)),
-             this,             SLOT(slotGotoSource(const QString&, int)) );
+    connect( gdbBreakpointWidget, TQT_SIGNAL(refreshBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( gdbBreakpointWidget, TQT_SIGNAL(publishBPState(const Breakpoint&)),
+             this,             TQT_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( gdbBreakpointWidget, TQT_SIGNAL(gotoSourcePosition(const TQString&, int)),
+             this,             TQT_SLOT(slotGotoSource(const TQString&, int)) );
 
 
     viewerWidget = new ViewerWidget( controller, 0, "viewerWidget");
@@ -179,15 +179,15 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
                                   i18n("Debug views"),
                                   i18n("Special debugger views"));
     mainWindow()->setViewAvailable(viewerWidget, false);
-    connect(viewerWidget, SIGNAL(setViewShown(bool)),
-            this, SLOT(slotShowView(bool)));
+    connect(viewerWidget, TQT_SIGNAL(setViewShown(bool)),
+            this, TQT_SLOT(slotShowView(bool)));
 
     // Now setup the actions
     KAction *action;
 
 //    action = new KAction(i18n("&Start"), "1rightarrow", CTRL+SHIFT+Key_F9,
     action = new KAction(i18n("&Start"), "dbgrun", 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>"
@@ -198,7 +198,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
                                "about variables, frame stack, and so on.") );
 
     action = new KAction(i18n("&Restart"), "dbgrestart", 0,
-                         this, SLOT(slotRestart()),
+                         this, TQT_SLOT(slotRestart()),
                          actionCollection(), "debug_restart");
     action->setToolTip( i18n("Restart program") );
     action->setWhatsThis( i18n("<b>Restarts application</b><p>"
@@ -208,33 +208,33 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     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 GDB 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("Set E&xecution Position to Cursor"), "dbgjumpto", 0,
-                         this, SLOT(slotJumpToCursor()),
+                         this, TQT_SLOT(slotJumpToCursor()),
                          actionCollection(), "debug_jumptocursor");
     action->setToolTip( i18n("Jump to cursor") );
     action->setWhatsThis(i18n("<b>Set Execution Position </b><p>Set the execution pointer to the current cursor position."));
 
 
     action = new KAction(i18n("Step &Over"), "dbgnext", Key_F10,
-                         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>"
@@ -245,14 +245,14 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     action = new KAction(i18n("Step over Ins&truction"), "dbgnextinst", 0,
-                         this, SLOT(slotStepOverInstruction()),
+                         this, TQT_SLOT(slotStepOverInstruction()),
                          actionCollection(), "debug_stepoverinst");
     action->setToolTip( i18n("Step over instruction") );
     action->setWhatsThis(i18n("<b>Step over instruction</b><p>Steps over the next assembly instruction."));
 
 
     action = new KAction(i18n("Step &Into"), "dbgstep", Key_F11,
-                         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>"
@@ -262,14 +262,14 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     action = new KAction(i18n("Step into I&nstruction"), "dbgstepinst", 0,
-                         this, SLOT(slotStepIntoInstruction()),
+                         this, TQT_SLOT(slotStepIntoInstruction()),
                          actionCollection(), "debug_stepintoinst");
     action->setToolTip( i18n("Step into instruction") );
     action->setWhatsThis(i18n("<b>Step into instruction</b><p>Steps into the next assembly instruction."));
 
 
     action = new KAction(i18n("Step O&ut"), "dbgstepout", Key_F12,
-                         this, SLOT(slotStepOut()),
+                         this, TQT_SLOT(slotStepOut()),
                          actionCollection(), "debug_stepout");
     action->setToolTip( i18n("Steps out of the current function") );
     action->setWhatsThis( i18n("<b>Step out</b><p>"
@@ -281,7 +281,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     action = new KAction(i18n("Viewers"), "dbgmemview", 0,
-                         this, SLOT(slotMemoryView()),
+                         this, TQT_SLOT(slotMemoryView()),
                          actionCollection(), "debug_memview");
     action->setToolTip( i18n("Debugger viewers") );
     action->setWhatsThis(i18n("<b>Debugger viewers</b><p>Various information about application being executed. There are 4 views available:<br>"
@@ -292,7 +292,7 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     action = new KAction(i18n("Examine Core File..."), "core", 0,
-                         this, SLOT(slotExamineCore()),
+                         this, TQT_SLOT(slotExamineCore()),
                          actionCollection(), "debug_core");
     action->setToolTip( i18n("Examine core file") );
     action->setWhatsThis( i18n("<b>Examine core file</b><p>"
@@ -304,72 +304,72 @@ DebuggerPart::DebuggerPart( QObject *parent, const char *name, const QStringList
 
 
     action = new KAction(i18n("Attach to Process"), "connect_creating", 0,
-                         this, SLOT(slotAttachProcess()),
+                         this, TQT_SLOT(slotAttachProcess()),
                          actionCollection(), "debug_attach");
     action->setToolTip( i18n("Attach to process") );
     action->setWhatsThis(i18n("<b>Attach to process</b><p>Attaches the debugger to a running process."));
 
     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( core(), SIGNAL(projectConfigWidget(KDialogBase*)),
-             this, SLOT(projectConfigWidget(KDialogBase*)) );
+    connect( core(), TQT_SIGNAL(projectConfigWidget(KDialogBase*)),
+             this, TQT_SLOT(projectConfigWidget(KDialogBase*)) );
 
-    connect( partController(), SIGNAL(loadedFile(const KURL &)),
-             gdbBreakpointWidget, SLOT(slotRefreshBP(const KURL &)) );
-    connect( debugger(), SIGNAL(toggledBreakpoint(const QString &, int)),
-             gdbBreakpointWidget, SLOT(slotToggleBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(editedBreakpoint(const QString &, int)),
-             gdbBreakpointWidget, SLOT(slotEditBreakpoint(const QString &, int)) );
-    connect( debugger(), SIGNAL(toggledBreakpointEnabled(const QString &, int)),
-             gdbBreakpointWidget, SLOT(slotToggleBreakpointEnabled(const QString &, int)) );
+    connect( partController(), TQT_SIGNAL(loadedFile(const KURL &)),
+             gdbBreakpointWidget, TQT_SLOT(slotRefreshBP(const KURL &)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpoint(const TQString &, int)),
+             gdbBreakpointWidget, TQT_SLOT(slotToggleBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(editedBreakpoint(const TQString &, int)),
+             gdbBreakpointWidget, TQT_SLOT(slotEditBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQT_SIGNAL(toggledBreakpointEnabled(const TQString &, int)),
+             gdbBreakpointWidget, 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, 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, SIGNAL(receivedPartialStdoutLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStdoutLine(const QCString&)));
-    connect( procLineMaker, SIGNAL(receivedPartialStderrLine(const QCString&)),
-             appFrontend(), SLOT(addPartialStderrLine(const QCString&)));
+    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&)));
 
     // The output from tracepoints goes to "application" window, because
     // we don't have any better alternative, and using yet another window
     // is undesirable. Besides, this makes tracepoint look even more similar
     // to printf debugging.
-    connect( gdbBreakpointWidget,   SIGNAL(tracingOutput(const char*)),
-             procLineMaker,         SLOT(slotReceivedStdout(const char*)));
+    connect( gdbBreakpointWidget,   TQT_SIGNAL(tracingOutput(const char*)),
+             procLineMaker,         TQT_SLOT(slotReceivedStdout(const char*)));
 
 
-    connect(partController(), SIGNAL(savedFile(const KURL &)),
-            this, SLOT(slotFileSaved()));
+    connect(partController(), TQT_SIGNAL(savedFile(const KURL &)),
+            this, TQT_SLOT(slotFileSaved()));
 
     if (project())
-        connect(project(), SIGNAL(projectCompiled()),
-                this, SLOT(slotProjectCompiled()));
+        connect(project(), TQT_SIGNAL(projectCompiled()),
+                this, TQT_SLOT(slotProjectCompiled()));
 
     setupController();
-    QTimer::singleShot(0, this, SLOT(setupDcop()));
+    TQTimer::singleShot(0, this, TQT_SLOT(setupDcop()));
 }
 
 void DebuggerPart::setupDcop()
@@ -379,24 +379,24 @@ void DebuggerPart::setupDcop()
         if ((*it).find("drkonqi-") == 0)
             slotDCOPApplicationRegistered(*it);
 
-    connect(kapp->dcopClient(), SIGNAL(applicationRegistered(const QCString&)), SLOT(slotDCOPApplicationRegistered(const QCString&)));
+    connect(kapp->dcopClient(), TQT_SIGNAL(applicationRegistered(const TQCString&)), TQT_SLOT(slotDCOPApplicationRegistered(const TQCString&)));
     kapp->dcopClient()->setNotifications(true);
 }
 
-void DebuggerPart::slotDCOPApplicationRegistered(const QCString& appId)
+void DebuggerPart::slotDCOPApplicationRegistered(const TQCString& appId)
 {
     if (appId.find("drkonqi-") == 0) {
-        QByteArray answer;
-        QCString replyType;
+        TQByteArray answer;
+        TQCString replyType;
 
-        kapp->dcopClient()->call(appId, "krashinfo", "appName()", QByteArray(), replyType, answer, true, 5000);
+        kapp->dcopClient()->call(appId, "krashinfo", "appName()", TQByteArray(), replyType, answer, true, 5000);
 
-        QDataStream d(answer, IO_ReadOnly);
-        QCString appName;
+        TQDataStream d(answer, IO_ReadOnly);
+        TQCString appName;
         d >> appName;
 
         if (appName.length() && project() && project()->mainProgram().endsWith(appName)) {
-            kapp->dcopClient()->send(appId, "krashinfo", "registerDebuggingApplication(QString)", i18n("Debug in &KDevelop"));
+            kapp->dcopClient()->send(appId, "krashinfo", "registerDebuggingApplication(TQString)", i18n("Debug in &KDevelop"));
             connectDCOPSignal(appId, "krashinfo", "acceptDebuggingApplication()", "slotDebugExternalProcess()", true);
         }
     }
@@ -404,32 +404,32 @@ void DebuggerPart::slotDCOPApplicationRegistered(const QCString& appId)
 
 ASYNC DebuggerPart::slotDebugExternalProcess()
 {
-    QByteArray answer;
-    QCString replyType;
+    TQByteArray answer;
+    TQCString replyType;
 
-    kapp->dcopClient()->call(kapp->dcopClient()->senderId(), "krashinfo", "pid()", QByteArray(), replyType, answer, true, 5000);
+    kapp->dcopClient()->call(kapp->dcopClient()->senderId(), "krashinfo", "pid()", TQByteArray(), replyType, answer, true, 5000);
 
-    QDataStream d(answer, IO_ReadOnly);
+    TQDataStream d(answer, IO_ReadOnly);
     int pid;
     d >> pid;
 
     if (attachProcess(pid) && m_drkonqi.isEmpty()) {
         m_drkonqi = kapp->dcopClient()->senderId();
-        QTimer::singleShot(15000, this, SLOT(slotCloseDrKonqi()));
+        TQTimer::singleShot(15000, this, TQT_SLOT(slotCloseDrKonqi()));
         mainWindow()->raiseView(framestackWidget);
     }
 
     mainWindow()->main()->raise();
 }
 
-ASYNC DebuggerPart::slotDebugCommandLine(const QString& /*command*/)
+ASYNC DebuggerPart::slotDebugCommandLine(const TQString& /*command*/)
 {
     KMessageBox::information(0, "Asked to debug command line");
 }
 
 void DebuggerPart::slotCloseDrKonqi()
 {
-    kapp->dcopClient()->send(m_drkonqi, "MainApplication-Interface", "quit()", QByteArray());
+    kapp->dcopClient()->send(m_drkonqi, "MainApplication-Interface", "quit()", TQByteArray());
     m_drkonqi = "";
 }
 
@@ -467,10 +467,10 @@ void DebuggerPart::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 DebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
+void DebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
 {
     if (!context->hasType( Context::EditorContext ))
         return;
@@ -491,13 +491,13 @@ void DebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
     int index = running ? 0 : -1;
     if (running)
     {
-        // Too bad we can't add QAction to popup menu in Qt3.
+        // Too bad we can't add TQAction to popup menu in Qt3.
         KAction* act = actionCollection()->action("debug_runtocursor");
         Q_ASSERT(act);
         if (act)
         {
             int id = popup->insertItem( act->iconSet(), i18n("Run to &Cursor"),
-                                        this, SLOT(slotRunToCursor()),
+                                        this, TQT_SLOT(slotRunToCursor()),
                                         0, -1, index);
 
             popup->setWhatsThis(id, act->whatsThis());
@@ -507,21 +507,21 @@ void DebuggerPart::contextMenu(QPopupMenu *popup, const Context *context)
     if (econtext->url().isLocalFile())
     {
         int id = popup->insertItem( i18n("Toggle Breakpoint"),
-                                    this, SLOT(toggleBreakpoint()),
+                                    this, TQT_SLOT(toggleBreakpoint()),
                                     0, -1, index);
         index += running;
         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);
+        TQString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
         int id = popup->insertItem( i18n("Evaluate: %1").arg(squeezed),
-                                    this, SLOT(contextEvaluate()),
+                                    this, TQT_SLOT(contextEvaluate()),
                                     0, -1, index);
         index += running;
         popup->setWhatsThis(id, i18n("<b>Evaluate expression</b><p>Shows the value of the expression under the cursor."));
         int id2 = popup->insertItem( i18n("Watch: %1").arg(squeezed),
-                                     this, SLOT(contextWatch()),
+                                     this, TQT_SLOT(contextWatch()),
                                     0, -1, index);
         index += running;
         popup->setWhatsThis(id2, i18n("<b>Watch expression</b><p>Adds an expression under the cursor to the Variables/Watch list."));
@@ -560,10 +560,10 @@ void DebuggerPart::contextEvaluate()
 
 void DebuggerPart::projectConfigWidget(KDialogBase *dlg)
 {
-    QVBox *vbox = dlg->addVBoxPage(i18n("Debugger"), i18n("Debugger"), BarIcon( info()->icon(), KIcon::SizeMedium) );
+    TQVBox *vbox = dlg->addVBoxPage(i18n("Debugger"), i18n("Debugger"), BarIcon( info()->icon(), KIcon::SizeMedium) );
     DebuggerConfigWidget *w = new DebuggerConfigWidget(this, vbox, "debugger config widget");
-    connect( dlg, SIGNAL(okClicked()), w, SLOT(accept()) );
-    connect( dlg, SIGNAL(finished()), controller, SLOT(configure()) );
+    connect( dlg, TQT_SIGNAL(okClicked()), w, TQT_SLOT(accept()) );
+    connect( dlg, TQT_SIGNAL(finished()), controller, TQT_SLOT(configure()) );
 }
 
 
@@ -572,68 +572,68 @@ void DebuggerPart::setupController()
     VariableTree *variableTree = variableWidget->varTree();
 
     // variableTree -> gdbBreakpointWidget
-    connect( variableTree,          SIGNAL(toggleWatchpoint(const QString &)),
-             gdbBreakpointWidget,   SLOT(slotToggleWatchpoint(const QString &)));
+    connect( variableTree,          TQT_SIGNAL(toggleWatchpoint(const TQString &)),
+             gdbBreakpointWidget,   TQT_SLOT(slotToggleWatchpoint(const TQString &)));
 
     // gdbOutputWidget -> controller
-    connect( gdbOutputWidget,       SIGNAL(userGDBCmd(const QString &)),
-             controller,            SLOT(slotUserGDBCmd(const QString&)));
-    connect( gdbOutputWidget,       SIGNAL(breakInto()),
-             controller,            SLOT(slotBreakInto()));
+    connect( gdbOutputWidget,       TQT_SIGNAL(userGDBCmd(const TQString &)),
+             controller,            TQT_SLOT(slotUserGDBCmd(const TQString&)));
+    connect( gdbOutputWidget,       TQT_SIGNAL(breakInto()),
+             controller,            TQT_SLOT(slotBreakInto()));
 
-    connect( controller,            SIGNAL(breakpointHit(int)),
-             gdbBreakpointWidget,   SLOT(slotBreakpointHit(int)));
+    connect( controller,            TQT_SIGNAL(breakpointHit(int)),
+             gdbBreakpointWidget,   TQT_SLOT(slotBreakpointHit(int)));
 
     // controller -> disassembleWidget
-    connect( controller,            SIGNAL(showStepInSource(const QString&, int, const QString&)),
-             disassembleWidget,     SLOT(slotShowStepInSource(const QString&, int, const QString&)));
+    connect( controller,            TQT_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
+             disassembleWidget,     TQT_SLOT(slotShowStepInSource(const TQString&, int, const TQString&)));
 
     // 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,            SIGNAL(debuggerAbnormalExit()),
-         this,                  SLOT(slotDebuggerAbnormalExit()));
+    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)));
+    connect( controller,            TQT_SIGNAL(debuggerAbnormalExit()),
+         this,                  TQT_SLOT(slotDebuggerAbnormalExit()));
 
-    connect(controller, SIGNAL(event(GDBController::event_t)),
-            this,       SLOT(slotEvent(GDBController::event_t)));
+    connect(controller, TQT_SIGNAL(event(GDBController::event_t)),
+            this,       TQT_SLOT(slotEvent(GDBController::event_t)));
 
     // 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 -> gdbOutputWidget
-    connect( controller,            SIGNAL(gdbInternalCommandStdout(const char*)),
-             gdbOutputWidget,       SLOT(slotInternalCommandStdout(const char*)) );
-    connect( controller,            SIGNAL(gdbUserCommandStdout(const char*)),
-             gdbOutputWidget,       SLOT(slotUserCommandStdout(const char*)) );
+    connect( controller,            TQT_SIGNAL(gdbInternalCommandStdout(const char*)),
+             gdbOutputWidget,       TQT_SLOT(slotInternalCommandStdout(const char*)) );
+    connect( controller,            TQT_SIGNAL(gdbUserCommandStdout(const char*)),
+             gdbOutputWidget,       TQT_SLOT(slotUserCommandStdout(const char*)) );
 
-    connect( controller,            SIGNAL(gdbStderr(const char*)),
-             gdbOutputWidget,       SLOT(slotReceivedStderr(const char*)) );
-    connect( controller,            SIGNAL(dbgStatus(const QString&, int)),
-             gdbOutputWidget,       SLOT(slotDbgStatus(const QString&, int)));
+    connect( controller,            TQT_SIGNAL(gdbStderr(const char*)),
+             gdbOutputWidget,       TQT_SLOT(slotReceivedStderr(const char*)) );
+    connect( controller,            TQT_SIGNAL(dbgStatus(const TQString&, int)),
+             gdbOutputWidget,       TQT_SLOT(slotDbgStatus(const TQString&, int)));
 
     // controller -> viewerWidget
-    connect( controller, SIGNAL(dbgStatus(const QString&, int)),
-             viewerWidget, SLOT(slotDebuggerState(const QString&, int)));
+    connect( controller, TQT_SIGNAL(dbgStatus(const TQString&, int)),
+             viewerWidget, TQT_SLOT(slotDebuggerState(const TQString&, int)));
 
 
-    connect(statusBarIndicator, SIGNAL(doubleClicked()),
-            controller, SLOT(explainDebuggerStatus()));
+    connect(statusBarIndicator, TQT_SIGNAL(doubleClicked()),
+            controller, TQT_SLOT(explainDebuggerStatus()));
 
 }
 
 
 bool DebuggerPart::startDebugger()
 {
-    QString build_dir;              // Currently selected build directory
+    TQString build_dir;              // Currently selected build directory
     DomUtil::PairList run_envvars;  // List with the environment variables
-    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
+    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
 
     if (project()) {
         build_dir     = project()->buildDirectory();
@@ -643,13 +643,13 @@ bool DebuggerPart::startDebugger()
         run_arguments = project()->debugArguments();
     }
 
-    QString shell = DomUtil::readEntry(*projectDom(), "/kdevdebugger/general/dbgshell");
+    TQString shell = DomUtil::readEntry(*projectDom(), "/kdevdebugger/general/dbgshell");
     if( !shell.isEmpty() )
     {
         shell = shell.simplifyWhiteSpace();
-        QString shell_without_args = QStringList::split(QChar(' '), shell ).first();
+        TQString shell_without_args = TQStringList::split(TQChar(' '), shell ).first();
 
-        QFileInfo info( shell_without_args );
+        TQFileInfo info( shell_without_args );
         if( info.isRelative() )
         {
             shell_without_args = build_dir + "/" + shell_without_args;
@@ -670,7 +670,7 @@ bool DebuggerPart::startDebugger()
     {
         core()->running(this, true);
 
-        stateChanged( QString("active") );
+        stateChanged( TQString("active") );
 
         KActionCollection *ac = actionCollection();
         ac->action("debug_run")->setText( i18n("&Continue") );
@@ -748,15 +748,15 @@ void DebuggerPart::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);
 }
 
 void DebuggerPart::slotShowView(bool show)
 {
-    const QWidget* s = static_cast<const QWidget*>(sender());
-    QWidget* ncs = const_cast<QWidget*>(s);
+    const TQWidget* s = static_cast<const TQWidget*>(sender());
+    TQWidget* ncs = const_cast<TQWidget*>(s);
     mainWindow()->setViewAvailable(ncs, show);
     if (show)
         mainWindow()->raiseView(ncs);
@@ -857,18 +857,18 @@ void DebuggerPart::slotRun()
 
             if (rebuild)
             {
-                disconnect(SIGNAL(buildProject()));
+                disconnect(TQT_SIGNAL(buildProject()));
                 // The KDevProject has no method to build the project,
                 // so try connecting to a slot has is present to all
                 // existing project managers.
                 // Note: this assumes that 'slotBuild' will save
                 // modified files.
 
-                if (connect(this, SIGNAL(buildProject()),
-                            project(), SLOT(slotBuild())))
+                if (connect(this, TQT_SIGNAL(buildProject()),
+                            project(), TQT_SLOT(slotBuild())))
                 {
-                    connect(project(), SIGNAL(projectCompiled()),
-                            this, SLOT(slotRun_part2()));
+                    connect(project(), TQT_SIGNAL(projectCompiled()),
+                            this, TQT_SLOT(slotRun_part2()));
 
                     emit buildProject();
                     rebuild = true;
@@ -894,8 +894,8 @@ void DebuggerPart::slotRun_part2()
 {
     needRebuild_ = false;
 
-    disconnect(project(), SIGNAL(projectCompiled()),
-               this, SLOT(slotRun_part2()));
+    disconnect(project(), TQT_SIGNAL(projectCompiled()),
+               this, TQT_SLOT(slotRun_part2()));
 
     if (controller->stateIsOn( s_dbgNotStarted ))
     {
@@ -950,8 +950,8 @@ void DebuggerPart::slotExamineCore()
 {
     mainWindow()->statusBar()->message(i18n("Choose a core file to examine..."), 1000);
 
-    QString dirName = project()? project()->projectDirectory() : QDir::homeDirPath();
-    QString coreFile = KFileDialog::getOpenFileName(dirName);
+    TQString dirName = project()? project()->projectDirectory() : TQDir::homeDirPath();
+    TQString coreFile = KFileDialog::getOpenFileName(dirName);
     if (coreFile.isNull())
         return;
 
@@ -1092,33 +1092,33 @@ void DebuggerPart::slotRefreshBPState( const Breakpoint& BP)
     }
 }
 
-void DebuggerPart::slotStatus(const QString &msg, int state)
+void DebuggerPart::slotStatus(const TQString &msg, int state)
 {
-    QString stateIndicator, stateIndicatorFull;
+    TQString stateIndicator, stateIndicatorFull;
 
     if (state & s_dbgNotStarted)
     {
         stateIndicator = " ";
         stateIndicatorFull = "Debugger not started";
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
     }
     else if (state & s_dbgBusy)
     {
         stateIndicator = "R";
         stateIndicatorFull = "Debugger is busy";
-        stateChanged( QString("active") );
+        stateChanged( TQString("active") );
     }
     else if (state & s_programExited)
     {
         stateIndicator = "E";
         stateIndicatorFull = "Application has exited";
-        stateChanged( QString("stopped") );
+        stateChanged( TQString("stopped") );
     }
     else
     {
         stateIndicator = "P";
         stateIndicatorFull = "Application is paused";
-        stateChanged( QString("paused") );
+        stateChanged( TQString("paused") );
         // On the first stop, show the variables view.
         // We do it on first stop, and not at debugger start, because
         // a program might just successfully run till completion. If we show
@@ -1173,7 +1173,7 @@ void DebuggerPart::slotStatus(const QString &msg, int state)
     kdDebug(9012) << "   " << msg << endl;
 
     statusBarIndicator->setText(stateIndicator);
-    QToolTip::add(statusBarIndicator, stateIndicatorFull);
+    TQToolTip::add(statusBarIndicator, stateIndicatorFull);
     if (!msg.isEmpty())
         mainWindow()->statusBar()->message(msg, 3000);
 
@@ -1192,7 +1192,7 @@ void DebuggerPart::slotEvent(GDBController::event_t e)
 }
 
 
-void DebuggerPart::slotShowStep(const QString &fileName, int lineNum)
+void DebuggerPart::slotShowStep(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
     {
@@ -1206,7 +1206,7 @@ void DebuggerPart::slotShowStep(const QString &fileName, int lineNum)
 }
 
 
-void DebuggerPart::slotGotoSource(const QString &fileName, int lineNum)
+void DebuggerPart::slotGotoSource(const TQString &fileName, int lineNum)
 {
     if ( ! fileName.isEmpty() )
         partController()->editDocument(KURL( fileName ), lineNum);
@@ -1229,13 +1229,13 @@ void DebuggerPart::slotActivePartChanged( KParts::Part* part )
     action->setEnabled( iface != 0 );
 }
 
-void DebuggerPart::restorePartialProjectSession(const QDomElement* el)
+void DebuggerPart::restorePartialProjectSession(const TQDomElement* el)
 {
     gdbBreakpointWidget->restorePartialProjectSession(el);
     gdbOutputWidget->restorePartialProjectSession(el);
 }
 
-void DebuggerPart::savePartialProjectSession(QDomElement* el)
+void DebuggerPart::savePartialProjectSession(TQDomElement* el)
 {
     gdbBreakpointWidget->savePartialProjectSession(el);
     gdbOutputWidget->savePartialProjectSession(el);