Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <[email protected]>

11 files changed, 212 insertions, 212 deletions

diff --git a/languages/cpp/debugger/dbgpsdlg.cpp b/languages/cpp/debugger/dbgpsdlg.cpp
index 63f6229b..f6791209 100644
--- a/languages/cpp/debugger/dbgpsdlg.cpp
+++ b/languages/cpp/debugger/dbgpsdlg.cpp
@@ -80,14 +80,14 @@ Dbg_PS_Dialog::Dbg_PS_Dialog(TQWidget *parent, const char *name)
     buttonbox->layout();
     topLayout->addWidget(buttonbox);
 
-    connect(ok,     TQT_SIGNAL(clicked()),  TQT_SLOT(accept()));
-    connect(cancel, TQT_SIGNAL(clicked()),  TQT_SLOT(reject()));  
+    connect(ok,     TQ_SIGNAL(clicked()),  TQ_SLOT(accept()));
+    connect(cancel, TQ_SIGNAL(clicked()),  TQ_SLOT(reject()));  
 
     // Default display to 40 chars wide, default height is okay
     resize( ((TDEGlobalSettings::fixedFont()).pointSize())*40, height());
     topLayout->activate();
 
-    TQTimer::singleShot(0, this, TQT_SLOT(slotInit()));
+    TQTimer::singleShot(0, this, TQ_SLOT(slotInit()));
 
 }
 
@@ -133,8 +133,8 @@ void Dbg_PS_Dialog::slotInit()
     }
 #endif
 
-    connect( psProc_, TQT_SIGNAL(processExited(TDEProcess *)),                TQT_SLOT(slotProcessExited()) );
-    connect( psProc_, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),  TQT_SLOT(slotReceivedOutput(TDEProcess *, char *, int)) );
+    connect( psProc_, TQ_SIGNAL(processExited(TDEProcess *)),                TQ_SLOT(slotProcessExited()) );
+    connect( psProc_, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),  TQ_SLOT(slotReceivedOutput(TDEProcess *, char *, int)) );
 
     psProc_->start(TDEProcess::NotifyOnExit, TDEProcess::Stdout);
 }
diff --git a/languages/cpp/debugger/dbgtoolbar.cpp b/languages/cpp/debugger/dbgtoolbar.cpp
index 13d01768..f9143fc0 100644
--- a/languages/cpp/debugger/dbgtoolbar.cpp
+++ b/languages/cpp/debugger/dbgtoolbar.cpp
@@ -111,9 +111,9 @@ void DbgMoveHandle::mousePressEvent(TQMouseEvent *e)
         TDEPopupMenu *menu = new TDEPopupMenu(this);
 	menu->insertTitle(i18n("Debug Toolbar"));
         menu->insertItem(i18n("Dock to Panel"),
-                         parent(), TQT_SLOT(slotDock()));
+                         parent(), TQ_SLOT(slotDock()));
         menu->insertItem(i18n("Dock to Panel && Iconify TDevelop"),
-                         parent(), TQT_SLOT(slotIconifyAndDock()));
+                         parent(), TQ_SLOT(slotIconifyAndDock()));
         menu->popup(e->globalPos());
     } else {
         moving_ = true;
@@ -243,8 +243,8 @@ void DbgDocker::mousePressEvent(TQMouseEvent *e)
         {
             TDEPopupMenu* menu = new TDEPopupMenu(this);
 	    menu->insertTitle(i18n("Debug Toolbar"));
-            menu->insertItem(i18n("Activate"),                        toolBar_, TQT_SLOT(slotUndock()));
-            menu->insertItem(i18n("Activate (TDevelop gets focus)"),  toolBar_, TQT_SLOT(slotActivateAndUndock()));
+            menu->insertItem(i18n("Activate"),                        toolBar_, TQ_SLOT(slotUndock()));
+            menu->insertItem(i18n("Activate (TDevelop gets focus)"),  toolBar_, TQ_SLOT(slotActivateAndUndock()));
             menu->popup(e->globalPos());
             break;
         }
@@ -272,7 +272,7 @@ DbgToolBar::DbgToolBar(DebuggerPart* part,
 {
     winModule_  = new KWinModule(this);
     docker_ = new DbgDocker(parent, this, BarIcon("dbgnext"));
-    connect(docker_, TQT_SIGNAL(clicked()), part_, TQT_SLOT(slotStepOver()));
+    connect(docker_, TQ_SIGNAL(clicked()), part_, TQ_SLOT(slotStepOver()));
 
     // Must have noFocus set so that we can see what window was active.
     // see slotDbgKdevFocus() for more comments
@@ -310,17 +310,17 @@ DbgToolBar::DbgToolBar(DebuggerPart* part,
     bKDevFocus_ = new DbgButton(BarIcon("tdevelop"),      TQString(),      this);
     bPrevFocus_ = new DbgButton(BarIcon("dbgmemview"),    TQString(),      this);
 
-  connect(bRun,        TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotRun()));
-  connect(bInterrupt,  TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotPause()));
-  connect(bNext,       TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepOver()));
-  connect(bNexti,      TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepOverInstruction()));
-  connect(bStep,       TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepInto()));
-  connect(bStepi,      TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepIntoInstruction()));
-  connect(bFinish,     TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotStepOut()));
-  connect(bRunTo,      TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotRunToCursor()));
-  connect(bView,       TQT_SIGNAL(clicked()), part_,  TQT_SLOT(slotMemoryView()));
-  connect(bKDevFocus_, TQT_SIGNAL(clicked()), this,   TQT_SLOT(slotKdevFocus()));
-  connect(bPrevFocus_, TQT_SIGNAL(clicked()), this,   TQT_SLOT(slotPrevFocus()));
+  connect(bRun,        TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotRun()));
+  connect(bInterrupt,  TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotPause()));
+  connect(bNext,       TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotStepOver()));
+  connect(bNexti,      TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotStepOverInstruction()));
+  connect(bStep,       TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotStepInto()));
+  connect(bStepi,      TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotStepIntoInstruction()));
+  connect(bFinish,     TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotStepOut()));
+  connect(bRunTo,      TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotRunToCursor()));
+  connect(bView,       TQ_SIGNAL(clicked()), part_,  TQ_SLOT(slotMemoryView()));
+  connect(bKDevFocus_, TQ_SIGNAL(clicked()), this,   TQ_SLOT(slotKdevFocus()));
+  connect(bPrevFocus_, TQ_SIGNAL(clicked()), this,   TQ_SLOT(slotPrevFocus()));
 
     TQToolTip::add( bRun,        i18n("Continue with application execution, may start the application") );
     TQToolTip::add( bInterrupt,  i18n("Interrupt the application execution") );
diff --git a/languages/cpp/debugger/debuggerpart.cpp b/languages/cpp/debugger/debuggerpart.cpp
index 6621cbf8..e2efd7b0 100644
--- a/languages/cpp/debugger/debuggerpart.cpp
+++ b/languages/cpp/debugger/debuggerpart.cpp
@@ -166,12 +166,12 @@ DebuggerPart::DebuggerPart( TQObject *parent, const char *name, const TQStringLi
     mainWindow()->setViewAvailable(gdbOutputWidget, false);
 
     // gdbBreakpointWidget -> this
-    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)) );
+    connect( gdbBreakpointWidget, TQ_SIGNAL(refreshBPState(const Breakpoint&)),
+             this,             TQ_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( gdbBreakpointWidget, TQ_SIGNAL(publishBPState(const Breakpoint&)),
+             this,             TQ_SLOT(slotRefreshBPState(const Breakpoint&)));
+    connect( gdbBreakpointWidget, TQ_SIGNAL(gotoSourcePosition(const TQString&, int)),
+             this,             TQ_SLOT(slotGotoSource(const TQString&, int)) );
 
 
     viewerWidget = new ViewerWidget( controller, 0, "viewerWidget");
@@ -179,15 +179,15 @@ DebuggerPart::DebuggerPart( TQObject *parent, const char *name, const TQStringLi
                                   i18n("Debug views"),
                                   i18n("Special debugger views"));
     mainWindow()->setViewAvailable(viewerWidget, false);
-    connect(viewerWidget, TQT_SIGNAL(setViewShown(bool)),
-            this, TQT_SLOT(slotShowView(bool)));
+    connect(viewerWidget, TQ_SIGNAL(setViewShown(bool)),
+            this, TQ_SLOT(slotShowView(bool)));
 
     // Now setup the actions
     TDEAction *action;
 
 //    action = new TDEAction(i18n("&Start"), "1rightarrow", CTRL+SHIFT+Key_F9,
     action = new TDEAction(i18n("&Start"), "dbgrun", Key_F9,
-                         this, TQT_SLOT(slotRun()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
                                "about variables, frame stack, and so on.") );
 
     action = new TDEAction(i18n("&Restart"), "dbgrestart", 0,
-                         this, TQT_SLOT(slotRestart()),
+                         this, TQ_SLOT(slotRestart()),
                          actionCollection(), "debug_restart");
     action->setToolTip( i18n("Restart program") );
     action->setWhatsThis( i18n("<b>Restarts application</b><p>"
@@ -208,33 +208,33 @@ DebuggerPart::DebuggerPart( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Sto&p"), "process-stop", 0,
-                         this, TQT_SLOT(slotStop()),
+                         this, TQ_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 TDEAction(i18n("Interrupt"), "media-playback-pause", 0,
-                         this, TQT_SLOT(slotPause()),
+                         this, TQ_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 TDEAction(i18n("Run to &Cursor"), "dbgrunto", 0,
-                         this, TQT_SLOT(slotRunToCursor()),
+                         this, TQ_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 TDEAction(i18n("Set E&xecution Position to Cursor"), "dbgjumpto", 0,
-                         this, TQT_SLOT(slotJumpToCursor()),
+                         this, TQ_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 TDEAction(i18n("Step &Over"), "dbgnext", Key_F10,
-                         this, TQT_SLOT(slotStepOver()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Step over Ins&truction"), "dbgnextinst", 0,
-                         this, TQT_SLOT(slotStepOverInstruction()),
+                         this, TQ_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 TDEAction(i18n("Step &Into"), "dbgstep", Key_F11,
-                         this, TQT_SLOT(slotStepInto()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Step into I&nstruction"), "dbgstepinst", 0,
-                         this, TQT_SLOT(slotStepIntoInstruction()),
+                         this, TQ_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 TDEAction(i18n("Step O&ut"), "dbgstepout", Key_F12,
-                         this, TQT_SLOT(slotStepOut()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Viewers"), "dbgmemview", 0,
-                         this, TQT_SLOT(slotMemoryView()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Examine Core File..."), "application-x-core", 0,
-                         this, TQT_SLOT(slotExamineCore()),
+                         this, TQ_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( TQObject *parent, const char *name, const TQStringLi
 
 
     action = new TDEAction(i18n("Attach to Process"), "connect_creating", 0,
-                         this, TQT_SLOT(slotAttachProcess()),
+                         this, TQ_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 TDEAction(i18n("Toggle Breakpoint"), 0, 0,
-                         this, TQT_SLOT(toggleBreakpoint()),
+                         this, TQ_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(), TQT_SIGNAL(clientAdded(KXMLGUIClient*)),
-             this, TQT_SLOT(guiClientAdded(KXMLGUIClient*)) );
+    connect( mainWindow()->main()->guiFactory(), TQ_SIGNAL(clientAdded(KXMLGUIClient*)),
+             this, TQ_SLOT(guiClientAdded(KXMLGUIClient*)) );
 
-    connect( core(), TQT_SIGNAL(projectConfigWidget(KDialogBase*)),
-             this, TQT_SLOT(projectConfigWidget(KDialogBase*)) );
+    connect( core(), TQ_SIGNAL(projectConfigWidget(KDialogBase*)),
+             this, TQ_SLOT(projectConfigWidget(KDialogBase*)) );
 
-    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( partController(), TQ_SIGNAL(loadedFile(const KURL &)),
+             gdbBreakpointWidget, TQ_SLOT(slotRefreshBP(const KURL &)) );
+    connect( debugger(), TQ_SIGNAL(toggledBreakpoint(const TQString &, int)),
+             gdbBreakpointWidget, TQ_SLOT(slotToggleBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQ_SIGNAL(editedBreakpoint(const TQString &, int)),
+             gdbBreakpointWidget, TQ_SLOT(slotEditBreakpoint(const TQString &, int)) );
+    connect( debugger(), TQ_SIGNAL(toggledBreakpointEnabled(const TQString &, int)),
+             gdbBreakpointWidget, TQ_SLOT(slotToggleBreakpointEnabled(const TQString &, int)) );
 
-    connect( core(), TQT_SIGNAL(contextMenu(TQPopupMenu *, const Context *)),
-             this, TQT_SLOT(contextMenu(TQPopupMenu *, const Context *)) );
+    connect( core(), TQ_SIGNAL(contextMenu(TQPopupMenu *, const Context *)),
+             this, TQ_SLOT(contextMenu(TQPopupMenu *, const Context *)) );
 
-    connect( core(), TQT_SIGNAL(stopButtonClicked(KDevPlugin*)),
-             this, TQT_SLOT(slotStop(KDevPlugin*)) );
-    connect( core(), TQT_SIGNAL(projectClosed()),
-             this, TQT_SLOT(projectClosed()) );
+    connect( core(), TQ_SIGNAL(stopButtonClicked(KDevPlugin*)),
+             this, TQ_SLOT(slotStop(KDevPlugin*)) );
+    connect( core(), TQ_SIGNAL(projectClosed()),
+             this, TQ_SLOT(projectClosed()) );
 
-    connect( partController(), TQT_SIGNAL(activePartChanged(KParts::Part*)),
-             this, TQT_SLOT(slotActivePartChanged(KParts::Part*)) );
+    connect( partController(), TQ_SIGNAL(activePartChanged(KParts::Part*)),
+             this, TQ_SLOT(slotActivePartChanged(KParts::Part*)) );
 
     procLineMaker = new ProcessLineMaker();
 
-    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, TQ_SIGNAL(receivedStdoutLine(const TQCString&)),
+             appFrontend(), TQ_SLOT(insertStdoutLine(const TQCString&)) );
+    connect( procLineMaker, TQ_SIGNAL(receivedStderrLine(const TQCString&)),
+             appFrontend(), TQ_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&)));
+    connect( procLineMaker, TQ_SIGNAL(receivedPartialStdoutLine(const TQCString&)),
+             appFrontend(), TQ_SLOT(addPartialStdoutLine(const TQCString&)));
+    connect( procLineMaker, TQ_SIGNAL(receivedPartialStderrLine(const TQCString&)),
+             appFrontend(), TQ_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,   TQT_SIGNAL(tracingOutput(const char*)),
-             procLineMaker,         TQT_SLOT(slotReceivedStdout(const char*)));
+    connect( gdbBreakpointWidget,   TQ_SIGNAL(tracingOutput(const char*)),
+             procLineMaker,         TQ_SLOT(slotReceivedStdout(const char*)));
 
 
-    connect(partController(), TQT_SIGNAL(savedFile(const KURL &)),
-            this, TQT_SLOT(slotFileSaved()));
+    connect(partController(), TQ_SIGNAL(savedFile(const KURL &)),
+            this, TQ_SLOT(slotFileSaved()));
 
     if (project())
-        connect(project(), TQT_SIGNAL(projectCompiled()),
-                this, TQT_SLOT(slotProjectCompiled()));
+        connect(project(), TQ_SIGNAL(projectCompiled()),
+                this, TQ_SLOT(slotProjectCompiled()));
 
     setupController();
-    TQTimer::singleShot(0, this, TQT_SLOT(setupDcop()));
+    TQTimer::singleShot(0, this, TQ_SLOT(setupDcop()));
 }
 
 void DebuggerPart::setupDcop()
@@ -379,7 +379,7 @@ void DebuggerPart::setupDcop()
         if ((*it).find("drkonqi-") == 0)
             slotDCOPApplicationRegistered(*it);
 
-    connect(kapp->dcopClient(), TQT_SIGNAL(applicationRegistered(const TQCString&)), TQT_SLOT(slotDCOPApplicationRegistered(const TQCString&)));
+    connect(kapp->dcopClient(), TQ_SIGNAL(applicationRegistered(const TQCString&)), TQ_SLOT(slotDCOPApplicationRegistered(const TQCString&)));
     kapp->dcopClient()->setNotifications(true);
 }
 
@@ -415,7 +415,7 @@ ASYNC DebuggerPart::slotDebugExternalProcess()
 
     if (attachProcess(pid) && m_drkonqi.isEmpty()) {
         m_drkonqi = kapp->dcopClient()->senderId();
-        TQTimer::singleShot(15000, this, TQT_SLOT(slotCloseDrKonqi()));
+        TQTimer::singleShot(15000, this, TQ_SLOT(slotCloseDrKonqi()));
         mainWindow()->raiseView(framestackWidget);
     }
 
@@ -497,7 +497,7 @@ void DebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
         if (act)
         {
             int id = popup->insertItem( act->iconSet(), i18n("Run to &Cursor"),
-                                        this, TQT_SLOT(slotRunToCursor()),
+                                        this, TQ_SLOT(slotRunToCursor()),
                                         0, -1, index);
 
             popup->setWhatsThis(id, act->whatsThis());
@@ -507,7 +507,7 @@ void DebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
     if (econtext->url().isLocalFile())
     {
         int id = popup->insertItem( i18n("Toggle Breakpoint"),
-                                    this, TQT_SLOT(toggleBreakpoint()),
+                                    this, TQ_SLOT(toggleBreakpoint()),
                                     0, -1, index);
         index += running;
         popup->setWhatsThis(id, i18n("<b>Toggle breakpoint</b><p>Toggles breakpoint at the current line."));
@@ -516,12 +516,12 @@ void DebuggerPart::contextMenu(TQPopupMenu *popup, const Context *context)
     {
         TQString squeezed = KStringHandler::csqueeze(m_contextIdent, 30);
         int id = popup->insertItem( i18n("Evaluate: %1").arg(squeezed),
-                                    this, TQT_SLOT(contextEvaluate()),
+                                    this, TQ_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, TQT_SLOT(contextWatch()),
+                                     this, TQ_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."));
@@ -562,8 +562,8 @@ void DebuggerPart::projectConfigWidget(KDialogBase *dlg)
 {
     TQVBox *vbox = dlg->addVBoxPage(i18n("Debugger"), i18n("Debugger"), BarIcon( info()->icon(), TDEIcon::SizeMedium) );
     DebuggerConfigWidget *w = new DebuggerConfigWidget(this, vbox, "debugger config widget");
-    connect( dlg, TQT_SIGNAL(okClicked()), w, TQT_SLOT(accept()) );
-    connect( dlg, TQT_SIGNAL(finished()), controller, TQT_SLOT(configure()) );
+    connect( dlg, TQ_SIGNAL(okClicked()), w, TQ_SLOT(accept()) );
+    connect( dlg, TQ_SIGNAL(finished()), controller, TQ_SLOT(configure()) );
 }
 
 
@@ -572,57 +572,57 @@ void DebuggerPart::setupController()
     VariableTree *variableTree = variableWidget->varTree();
 
     // variableTree -> gdbBreakpointWidget
-    connect( variableTree,          TQT_SIGNAL(toggleWatchpoint(const TQString &)),
-             gdbBreakpointWidget,   TQT_SLOT(slotToggleWatchpoint(const TQString &)));
+    connect( variableTree,          TQ_SIGNAL(toggleWatchpoint(const TQString &)),
+             gdbBreakpointWidget,   TQ_SLOT(slotToggleWatchpoint(const TQString &)));
 
     // gdbOutputWidget -> controller
-    connect( gdbOutputWidget,       TQT_SIGNAL(userGDBCmd(const TQString &)),
-             controller,            TQT_SLOT(slotUserGDBCmd(const TQString&)));
-    connect( gdbOutputWidget,       TQT_SIGNAL(breakInto()),
-             controller,            TQT_SLOT(slotBreakInto()));
+    connect( gdbOutputWidget,       TQ_SIGNAL(userGDBCmd(const TQString &)),
+             controller,            TQ_SLOT(slotUserGDBCmd(const TQString&)));
+    connect( gdbOutputWidget,       TQ_SIGNAL(breakInto()),
+             controller,            TQ_SLOT(slotBreakInto()));
 
-    connect( controller,            TQT_SIGNAL(breakpointHit(int)),
-             gdbBreakpointWidget,   TQT_SLOT(slotBreakpointHit(int)));
+    connect( controller,            TQ_SIGNAL(breakpointHit(int)),
+             gdbBreakpointWidget,   TQ_SLOT(slotBreakpointHit(int)));
 
     // controller -> disassembleWidget
-    connect( controller,            TQT_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
-             disassembleWidget,     TQT_SLOT(slotShowStepInSource(const TQString&, int, const TQString&)));
+    connect( controller,            TQ_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
+             disassembleWidget,     TQ_SLOT(slotShowStepInSource(const TQString&, int, const TQString&)));
 
     // controller -> this
-    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,            TQ_SIGNAL(dbgStatus(const TQString&, int)),
+             this,                  TQ_SLOT(slotStatus(const TQString&, int)));
+    connect( controller,            TQ_SIGNAL(showStepInSource(const TQString&, int, const TQString&)),
+             this,                  TQ_SLOT(slotShowStep(const TQString&, int)));
+    connect( controller,            TQ_SIGNAL(debuggerAbnormalExit()),
+         this,                  TQ_SLOT(slotDebuggerAbnormalExit()));
 
-    connect(controller, TQT_SIGNAL(event(GDBController::event_t)),
-            this,       TQT_SLOT(slotEvent(GDBController::event_t)));
+    connect(controller, TQ_SIGNAL(event(GDBController::event_t)),
+            this,       TQ_SLOT(slotEvent(GDBController::event_t)));
 
     // controller -> procLineMaker
-    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*)));
+    connect( controller,            TQ_SIGNAL(ttyStdout(const char*)),
+             procLineMaker,         TQ_SLOT(slotReceivedStdout(const char*)));
+    connect( controller,            TQ_SIGNAL(ttyStderr(const char*)),
+             procLineMaker,         TQ_SLOT(slotReceivedStderr(const char*)));
 
     // controller -> gdbOutputWidget
-    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,            TQ_SIGNAL(gdbInternalCommandStdout(const char*)),
+             gdbOutputWidget,       TQ_SLOT(slotInternalCommandStdout(const char*)) );
+    connect( controller,            TQ_SIGNAL(gdbUserCommandStdout(const char*)),
+             gdbOutputWidget,       TQ_SLOT(slotUserCommandStdout(const char*)) );
 
-    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)));
+    connect( controller,            TQ_SIGNAL(gdbStderr(const char*)),
+             gdbOutputWidget,       TQ_SLOT(slotReceivedStderr(const char*)) );
+    connect( controller,            TQ_SIGNAL(dbgStatus(const TQString&, int)),
+             gdbOutputWidget,       TQ_SLOT(slotDbgStatus(const TQString&, int)));
 
     // controller -> viewerWidget
-    connect( controller, TQT_SIGNAL(dbgStatus(const TQString&, int)),
-             viewerWidget, TQT_SLOT(slotDebuggerState(const TQString&, int)));
+    connect( controller, TQ_SIGNAL(dbgStatus(const TQString&, int)),
+             viewerWidget, TQ_SLOT(slotDebuggerState(const TQString&, int)));
 
 
-    connect(statusBarIndicator, TQT_SIGNAL(doubleClicked()),
-            controller, TQT_SLOT(explainDebuggerStatus()));
+    connect(statusBarIndicator, TQ_SIGNAL(doubleClicked()),
+            controller, TQ_SLOT(explainDebuggerStatus()));
 
 }
 
@@ -857,18 +857,18 @@ void DebuggerPart::slotRun()
 
             if (rebuild)
             {
-                disconnect(TQT_SIGNAL(buildProject()));
+                disconnect(TQ_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, TQT_SIGNAL(buildProject()),
-                            project(), TQT_SLOT(slotBuild())))
+                if (connect(this, TQ_SIGNAL(buildProject()),
+                            project(), TQ_SLOT(slotBuild())))
                 {
-                    connect(project(), TQT_SIGNAL(projectCompiled()),
-                            this, TQT_SLOT(slotRun_part2()));
+                    connect(project(), TQ_SIGNAL(projectCompiled()),
+                            this, TQ_SLOT(slotRun_part2()));
 
                     emit buildProject();
                     rebuild = true;
@@ -894,8 +894,8 @@ void DebuggerPart::slotRun_part2()
 {
     needRebuild_ = false;
 
-    disconnect(project(), TQT_SIGNAL(projectCompiled()),
-               this, TQT_SLOT(slotRun_part2()));
+    disconnect(project(), TQ_SIGNAL(projectCompiled()),
+               this, TQ_SLOT(slotRun_part2()));
 
     if (controller->stateIsOn( s_dbgNotStarted ))
     {
diff --git a/languages/cpp/debugger/debuggertracingdialog.cpp b/languages/cpp/debugger/debuggertracingdialog.cpp
index 90657b29..6d1122ee 100644
--- a/languages/cpp/debugger/debuggertracingdialog.cpp
+++ b/languages/cpp/debugger/debuggertracingdialog.cpp
@@ -19,11 +19,11 @@ namespace GDBDebugger
     {
         expressions->setButtons(KEditListBox::Add | KEditListBox::Remove);
 
-        connect(enable, TQT_SIGNAL(stateChanged(int)),
-                this, TQT_SLOT(enableOrDisable(int)));        
+        connect(enable, TQ_SIGNAL(stateChanged(int)),
+                this, TQ_SLOT(enableOrDisable(int)));        
         
-        connect(enableCustomFormat, TQT_SIGNAL(stateChanged(int)),
-                this, TQT_SLOT(enableOrDisableCustomFormat(int)));
+        connect(enableCustomFormat, TQ_SIGNAL(stateChanged(int)),
+                this, TQ_SLOT(enableOrDisableCustomFormat(int)));
 
         enable->setChecked(bp_->tracingEnabled());
         expressions->setItems(bp_->tracedExpressions());
diff --git a/languages/cpp/debugger/framestackwidget.cpp b/languages/cpp/debugger/framestackwidget.cpp
index 423fae89..e81bf590 100644
--- a/languages/cpp/debugger/framestackwidget.cpp
+++ b/languages/cpp/debugger/framestackwidget.cpp
@@ -57,11 +57,11 @@ FramestackWidget::FramestackWidget(GDBController* controller,
 
     // FIXME: maybe, all debugger components should derive from
     // a base class that does this connect.
-    connect(controller, TQT_SIGNAL(event(GDBController::event_t)),
-            this,       TQT_SLOT(slotEvent(GDBController::event_t)));
+    connect(controller, TQ_SIGNAL(event(GDBController::event_t)),
+            this,       TQ_SLOT(slotEvent(GDBController::event_t)));
 
-    connect( this, TQT_SIGNAL(clicked(TQListViewItem*)),
-             this, TQT_SLOT(slotSelectionChanged(TQListViewItem*)) );
+    connect( this, TQ_SIGNAL(clicked(TQListViewItem*)),
+             this, TQ_SLOT(slotSelectionChanged(TQListViewItem*)) );
 }
 
 
diff --git a/languages/cpp/debugger/gdbbreakpointwidget.cpp b/languages/cpp/debugger/gdbbreakpointwidget.cpp
index c777226a..c8064711 100644
--- a/languages/cpp/debugger/gdbbreakpointwidget.cpp
+++ b/languages/cpp/debugger/gdbbreakpointwidget.cpp
@@ -145,8 +145,8 @@ void BreakpointTableRow::appendEmptyRow()
 
     ComplexEditCell* act = new ComplexEditCell(table());
     table()->setItem(row, Tracing, act);
-    TQObject::connect(act, TQT_SIGNAL(edit(TQTableItem*)),
-                     table()->parent(), TQT_SLOT(editTracing(TQTableItem*)));
+    TQObject::connect(act, TQ_SIGNAL(edit(TQTableItem*)),
+                     table()->parent(), TQ_SLOT(editTracing(TQTableItem*)));
 }
 
 /***************************************************************************/
@@ -251,39 +251,39 @@ controller_(controller)
 
     m_table->show();
 
-    connect( newBreakpoint,       TQT_SIGNAL(activated(int)),
-             this,          TQT_SLOT(slotAddBlankBreakpoint(int)) );
+    connect( newBreakpoint,       TQ_SIGNAL(activated(int)),
+             this,          TQ_SLOT(slotAddBlankBreakpoint(int)) );
 
-    connect( m_table,       TQT_SIGNAL(contextMenuRequested(int, int, const TQPoint &)),
-             this,          TQT_SLOT(slotContextMenuShow(int, int, const TQPoint & )) );
-    connect( m_ctxMenu,     TQT_SIGNAL(activated(int)),
-             this,          TQT_SLOT(slotContextMenuSelect(int)) );
+    connect( m_table,       TQ_SIGNAL(contextMenuRequested(int, int, const TQPoint &)),
+             this,          TQ_SLOT(slotContextMenuShow(int, int, const TQPoint & )) );
+    connect( m_ctxMenu,     TQ_SIGNAL(activated(int)),
+             this,          TQ_SLOT(slotContextMenuSelect(int)) );
 
-    connect( m_table,       TQT_SIGNAL(doubleClicked(int, int, int, const TQPoint &)),
-             this,          TQT_SLOT(slotRowDoubleClicked(int, int, int, const TQPoint &)));
+    connect( m_table,       TQ_SIGNAL(doubleClicked(int, int, int, const TQPoint &)),
+             this,          TQ_SLOT(slotRowDoubleClicked(int, int, int, const TQPoint &)));
 
-    connect( m_table,       TQT_SIGNAL(valueChanged(int, int)),
-             this,          TQT_SLOT(slotNewValue(int, int)));
+    connect( m_table,       TQ_SIGNAL(valueChanged(int, int)),
+             this,          TQ_SLOT(slotNewValue(int, int)));
 
-    connect( m_table,       TQT_SIGNAL(returnPressed()),
-             this,          TQT_SLOT(slotEditBreakpoint()));
-//    connect( m_table,       TQT_SIGNAL(f2Pressed()),
-//             this,          TQT_SLOT(slotEditBreakpoint()));
-    connect( m_table,       TQT_SIGNAL(deletePressed()),
-             this,          TQT_SLOT(slotRemoveBreakpoint()));
+    connect( m_table,       TQ_SIGNAL(returnPressed()),
+             this,          TQ_SLOT(slotEditBreakpoint()));
+//    connect( m_table,       TQ_SIGNAL(f2Pressed()),
+//             this,          TQ_SLOT(slotEditBreakpoint()));
+    connect( m_table,       TQ_SIGNAL(deletePressed()),
+             this,          TQ_SLOT(slotRemoveBreakpoint()));
 // This slot doesn't exist anymore
-//     connect( m_table,       TQT_SIGNAL(insertPressed()),
-//              this,          TQT_SLOT(slotAddBlankBreakpoint()));
+//     connect( m_table,       TQ_SIGNAL(insertPressed()),
+//              this,          TQ_SLOT(slotAddBlankBreakpoint()));
 
     // FIXME: maybe, all debugger components should derive from
     // a base class that does this connect.
-    connect(controller, TQT_SIGNAL(event(GDBController::event_t)),
-            this,       TQT_SLOT(slotEvent(GDBController::event_t)));
+    connect(controller, TQ_SIGNAL(event(GDBController::event_t)),
+            this,       TQ_SLOT(slotEvent(GDBController::event_t)));
 
     connect(controller,
-            TQT_SIGNAL(watchpointHit(int, const TQString&, const TQString&)),
+            TQ_SIGNAL(watchpointHit(int, const TQString&, const TQString&)),
             this,
-            TQT_SLOT(slotWatchpointHit(int, const TQString&, const TQString&)));
+            TQ_SLOT(slotWatchpointHit(int, const TQString&, const TQString&)));
 }
 
 /***************************************************************************/
@@ -453,8 +453,8 @@ BreakpointTableRow* GDBBreakpointWidget::addBreakpoint(Breakpoint *bp)
     BreakpointTableRow* btr =
         new BreakpointTableRow( m_table, TQTableItem::WhenCurrent, bp );
 
-    connect(bp, TQT_SIGNAL(modified(Breakpoint*)),
-            this, TQT_SLOT(slotBreakpointModified(Breakpoint*)));
+    connect(bp, TQ_SIGNAL(modified(Breakpoint*)),
+            this, TQ_SLOT(slotBreakpointModified(Breakpoint*)));
 
     sendToGdb(*bp);
 
@@ -1238,7 +1238,7 @@ TQWidget* ComplexEditCell::createEditor() const
     // than 20.
     b->setFixedWidth( 20 );
 
-    connect(b, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotEdit()));
+    connect(b, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotEdit()));
 
     return box;
 }
diff --git a/languages/cpp/debugger/gdbcontroller.cpp b/languages/cpp/debugger/gdbcontroller.cpp
index bca8b98d..c89eb46b 100644
--- a/languages/cpp/debugger/gdbcontroller.cpp
+++ b/languages/cpp/debugger/gdbcontroller.cpp
@@ -798,17 +798,17 @@ bool GDBController::start(const TQString& shell, const DomUtil::PairList& run_en
 
     dbgProcess_ = new TDEProcess;
 
-    connect( dbgProcess_, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
-             this,        TQT_SLOT(slotDbgStdout(TDEProcess *, char *, int)) );
+    connect( dbgProcess_, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
+             this,        TQ_SLOT(slotDbgStdout(TDEProcess *, char *, int)) );
 
-    connect( dbgProcess_, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
-             this,        TQT_SLOT(slotDbgStderr(TDEProcess *, char *, int)) );
+    connect( dbgProcess_, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
+             this,        TQ_SLOT(slotDbgStderr(TDEProcess *, char *, int)) );
 
-    connect( dbgProcess_, TQT_SIGNAL(wroteStdin(TDEProcess *)),
-             this,        TQT_SLOT(slotDbgWroteStdin(TDEProcess *)) );
+    connect( dbgProcess_, TQ_SIGNAL(wroteStdin(TDEProcess *)),
+             this,        TQ_SLOT(slotDbgWroteStdin(TDEProcess *)) );
 
-    connect( dbgProcess_, TQT_SIGNAL(processExited(TDEProcess*)),
-             this,        TQT_SLOT(slotDbgProcessExited(TDEProcess*)) );
+    connect( dbgProcess_, TQ_SIGNAL(processExited(TDEProcess*)),
+             this,        TQ_SLOT(slotDbgProcessExited(TDEProcess*)) );
 
     application_ = application;
 
@@ -1101,8 +1101,8 @@ void GDBController::slotRun()
         tty_ = new STTY(config_dbgTerminal_, Settings::terminalEmulatorName( *kapp->config() ));
         if (!config_dbgTerminal_)
         {
-            connect( tty_, TQT_SIGNAL(OutOutput(const char*)), TQT_SIGNAL(ttyStdout(const char*)) );
-            connect( tty_, TQT_SIGNAL(ErrOutput(const char*)), TQT_SIGNAL(ttyStderr(const char*)) );
+            connect( tty_, TQ_SIGNAL(OutOutput(const char*)), TQ_SIGNAL(ttyStdout(const char*)) );
+            connect( tty_, TQ_SIGNAL(ErrOutput(const char*)), TQ_SIGNAL(ttyStderr(const char*)) );
         }
 
         TQString tty(tty_->getSlave());
diff --git a/languages/cpp/debugger/gdboutputwidget.cpp b/languages/cpp/debugger/gdboutputwidget.cpp
index deabf2c8..74ce3dc1 100644
--- a/languages/cpp/debugger/gdboutputwidget.cpp
+++ b/languages/cpp/debugger/gdboutputwidget.cpp
@@ -78,11 +78,11 @@ GDBOutputWidget::GDBOutputWidget( TQWidget *parent, const char *name) :
 
     slotDbgStatus( "", s_dbgNotStarted);
 
-    connect( m_userGDBCmdEditor, TQT_SIGNAL(returnPressed()), TQT_SLOT(slotGDBCmd()) );
-    connect( m_Interrupt,        TQT_SIGNAL(clicked()),       TQT_SIGNAL(breakInto()));
+    connect( m_userGDBCmdEditor, TQ_SIGNAL(returnPressed()), TQ_SLOT(slotGDBCmd()) );
+    connect( m_Interrupt,        TQ_SIGNAL(clicked()),       TQ_SIGNAL(breakInto()));
 
-    connect( &updateTimer_, TQT_SIGNAL(timeout()),
-             this,  TQT_SLOT(flushPending()));
+    connect( &updateTimer_, TQ_SIGNAL(timeout()),
+             this,  TQ_SLOT(flushPending()));
 }
 
 /***************************************************************************/
@@ -325,7 +325,7 @@ TQPopupMenu* OutputText::createPopupMenu(const TQPoint&)
 
     int id = popup->insertItem(i18n("Show Internal Commands"),
                                this,
-                               TQT_SLOT(toggleShowInternalCommands()));
+                               TQ_SLOT(toggleShowInternalCommands()));
 
     popup->setItemChecked(id, parent_->showInternalCommands_);
     popup->setWhatsThis(
@@ -338,7 +338,7 @@ TQPopupMenu* OutputText::createPopupMenu(const TQPoint&)
 
     popup->insertItem(i18n("Copy All"),
                       this,
-                      TQT_SLOT(copyAll()));
+                      TQ_SLOT(copyAll()));
 
 
     return popup;
diff --git a/languages/cpp/debugger/memviewdlg.cpp b/languages/cpp/debugger/memviewdlg.cpp
index 42ad9d4c..86f7e61c 100644
--- a/languages/cpp/debugger/memviewdlg.cpp
+++ b/languages/cpp/debugger/memviewdlg.cpp
@@ -116,11 +116,11 @@ namespace GDBDebugger
 
             l->addSpacing(2);
 
-            connect(startAddressLineEdit, TQT_SIGNAL(returnPressed()),
-                    okButton, TQT_SLOT(animateClick()));
+            connect(startAddressLineEdit, TQ_SIGNAL(returnPressed()),
+                    okButton, TQ_SLOT(animateClick()));
 
-            connect(amountLineEdit, TQT_SIGNAL(returnPressed()),
-                    okButton, TQT_SLOT(animateClick()));
+            connect(amountLineEdit, TQ_SIGNAL(returnPressed()),
+                    okButton, TQ_SLOT(animateClick()));
         }
     };
 
@@ -162,8 +162,8 @@ namespace GDBDebugger
             {
                 ok_ = true;
 
-                connect(real_widget, TQT_SIGNAL(bufferChanged(int, int)),
-                        this, TQT_SLOT(memoryEdited(int, int)));
+                connect(real_widget, TQ_SIGNAL(bufferChanged(int, int)),
+                        this, TQ_SLOT(memoryEdited(int, int)));
                 
                 khexedit2_real_widget = real_widget;
 
@@ -197,22 +197,22 @@ namespace GDBDebugger
             rangeSelector_ = new MemoryRangeSelector(this);
             l->addWidget(rangeSelector_);
             
-            connect(rangeSelector_->okButton, TQT_SIGNAL(clicked()),
-                    this,                     TQT_SLOT(slotChangeMemoryRange()));
+            connect(rangeSelector_->okButton, TQ_SIGNAL(clicked()),
+                    this,                     TQ_SLOT(slotChangeMemoryRange()));
             
             
-            connect(rangeSelector_->cancelButton,  TQT_SIGNAL(clicked()), 
-                    this,                         TQT_SLOT(slotHideRangeDialog()));
+            connect(rangeSelector_->cancelButton,  TQ_SIGNAL(clicked()), 
+                    this,                         TQ_SLOT(slotHideRangeDialog()));
             
             connect(rangeSelector_->startAddressLineEdit,
-                    TQT_SIGNAL(textChanged(const TQString&)),
+                    TQ_SIGNAL(textChanged(const TQString&)),
                     this,
-                    TQT_SLOT(slotEnableOrDisable()));
+                    TQ_SLOT(slotEnableOrDisable()));
             
             connect(rangeSelector_->amountLineEdit,
-                    TQT_SIGNAL(textChanged(const TQString&)),
+                    TQ_SIGNAL(textChanged(const TQString&)),
                     this,
-                    TQT_SLOT(slotEnableOrDisable()));
+                    TQ_SLOT(slotEnableOrDisable()));
 
             l->addWidget(khexedit2_widget);
 
@@ -436,11 +436,11 @@ namespace GDBDebugger
         toolBox_->setCurrentItem(widget);
         memoryViews_.push_back(widget);
 
-        connect(widget, TQT_SIGNAL(captionChanged(const TQString&)),
-                this, TQT_SLOT(slotChildCaptionChanged(const TQString&)));
+        connect(widget, TQ_SIGNAL(captionChanged(const TQString&)),
+                this, TQ_SLOT(slotChildCaptionChanged(const TQString&)));
 
-        connect(widget, TQT_SIGNAL(destroyed(TQObject*)),
-                this, TQT_SLOT(slotChildDestroyed(TQObject*)));
+        connect(widget, TQ_SIGNAL(destroyed(TQObject*)),
+                this, TQ_SLOT(slotChildDestroyed(TQObject*)));
     }
 
     void ViewerWidget::slotDebuggerState(const TQString&, int state)
diff --git a/languages/cpp/debugger/stty.cpp b/languages/cpp/debugger/stty.cpp
index 6960ad6d..9d95ad0d 100644
--- a/languages/cpp/debugger/stty.cpp
+++ b/languages/cpp/debugger/stty.cpp
@@ -132,7 +132,7 @@ STTY::STTY(bool ext, const TQString &termAppName)
         if (fout >= 0) {
             ttySlave = TQString(tty_slave);
             out = new TQSocketNotifier(fout, TQSocketNotifier::Read, this);
-            connect( out, TQT_SIGNAL(activated(int)), this, TQT_SLOT(OutReceived(int)) );
+            connect( out, TQ_SIGNAL(activated(int)), this, TQ_SLOT(OutReceived(int)) );
         }
     }
 }
diff --git a/languages/cpp/debugger/variablewidget.cpp b/languages/cpp/debugger/variablewidget.cpp
index 5750d243..e46db5dc 100644
--- a/languages/cpp/debugger/variablewidget.cpp
+++ b/languages/cpp/debugger/variablewidget.cpp
@@ -104,14 +104,14 @@ VariableWidget::VariableWidget(GDBController*  controller,
     topLayout->addItem(buttons);
 
 
-    connect( addButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddWatchVariable()) );
-    connect( evalButton, TQT_SIGNAL(clicked()), TQT_SLOT(slotEvaluateExpression()) );
+    connect( addButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotAddWatchVariable()) );
+    connect( evalButton, TQ_SIGNAL(clicked()), TQ_SLOT(slotEvaluateExpression()) );
 
-    connect( watchVarEditor_, TQT_SIGNAL(returnPressed()),
-             TQT_SLOT(slotEvaluateExpression()) );
+    connect( watchVarEditor_, TQ_SIGNAL(returnPressed()),
+             TQ_SLOT(slotEvaluateExpression()) );
 
-    connect(controller, TQT_SIGNAL(event(GDBController::event_t)),
-            varTree_,       TQT_SLOT(slotEvent(GDBController::event_t)));
+    connect(controller, TQ_SIGNAL(event(GDBController::event_t)),
+            varTree_,       TQ_SLOT(slotEvent(GDBController::event_t)));
 
 
     // Setup help items.
@@ -223,10 +223,10 @@ VariableTree::VariableTree(VariableWidget *parent,
     addColumn(i18n("Value"));
 //     setResizeMode(AllColumns);
 
-    connect( this, TQT_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)),
-             TQT_SLOT(slotContextMenu(TDEListView*, TQListViewItem*)) );
-    connect( this, TQT_SIGNAL(itemRenamed( TQListViewItem*, int, const TQString&)),
-             this, TQT_SLOT(slotItemRenamed( TQListViewItem*, int, const TQString&)));
+    connect( this, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)),
+             TQ_SLOT(slotContextMenu(TDEListView*, TQListViewItem*)) );
+    connect( this, TQ_SIGNAL(itemRenamed( TQListViewItem*, int, const TQString&)),
+             this, TQ_SLOT(slotItemRenamed( TQListViewItem*, int, const TQString&)));
 }
 
 // **************************************************************************
@@ -1085,9 +1085,9 @@ VarItem::VarItem(TrimmableItem *parent,
       baseClassMember_(false),
       alive_(true)
 {
-    connect(this, TQT_SIGNAL(varobjNameChange(const TQString&, const TQString&)),
+    connect(this, TQ_SIGNAL(varobjNameChange(const TQString&, const TQString&)),
             varTree(),
-            TQT_SLOT(slotVarobjNameChanged(const TQString&, const TQString&)));
+            TQ_SLOT(slotVarobjNameChanged(const TQString&, const TQString&)));
 
 
     // User might have entered format together with expression: like
@@ -1130,9 +1130,9 @@ VarItem::VarItem(TrimmableItem *parent, const GDBMI::Value& varobj,
   baseClassMember_(baseClassMember),
   alive_(true)
 {
-    connect(this, TQT_SIGNAL(varobjNameChange(const TQString&, const TQString&)),
+    connect(this, TQ_SIGNAL(varobjNameChange(const TQString&, const TQString&)),
             varTree(),
-            TQT_SLOT(slotVarobjNameChanged(const TQString&, const TQString&)));
+            TQ_SLOT(slotVarobjNameChanged(const TQString&, const TQString&)));
 
     expression_ = varobj["exp"].literal();
     varobjName_ = varobj["name"].literal();