Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 5cccb18e084303566a42c629b5b0f464f9133830)

14 files changed, 186 insertions, 186 deletions

diff --git a/kdbg/brkpt.cpp b/kdbg/brkpt.cpp
index 54e1548..122d824 100644
--- a/kdbg/brkpt.cpp
+++ b/kdbg/brkpt.cpp
@@ -50,27 +50,27 @@ BreakpointTable::BreakpointTable(TQWidget* parent, const char* name) :
 	m_buttons(8)
 {
     m_bpEdit.setMinimumSize(m_bpEdit.sizeHint());
-    connect(&m_bpEdit, SIGNAL(returnPressed()), this, SLOT(addBP()));
+    connect(&m_bpEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(addBP()));
 
     initListAndIcons();
-    connect(&m_list, SIGNAL(currentChanged(TQListViewItem*)), SLOT(updateUI()));
+    connect(&m_list, TQ_SIGNAL(currentChanged(TQListViewItem*)), TQ_SLOT(updateUI()));
     // double click on item is same as View code
-    connect(&m_list, SIGNAL(doubleClicked(TQListViewItem*)), this, SLOT(viewBP()));
+    connect(&m_list, TQ_SIGNAL(doubleClicked(TQListViewItem*)), this, TQ_SLOT(viewBP()));
 
     // need mouse button events
     m_list.viewport()->installEventFilter(this);
 
     m_btAddBP.setText(i18n("Add &Breakpoint"));
     m_btAddBP.setMinimumSize(m_btAddBP.sizeHint());
-    connect(&m_btAddBP, SIGNAL(clicked()), this, SLOT(addBP()));
+    connect(&m_btAddBP, TQ_SIGNAL(clicked()), this, TQ_SLOT(addBP()));
 
     m_btAddWP.setText(i18n("Add &Watchpoint"));
     m_btAddWP.setMinimumSize(m_btAddWP.sizeHint());
-    connect(&m_btAddWP, SIGNAL(clicked()), this, SLOT(addWP()));
+    connect(&m_btAddWP, TQ_SIGNAL(clicked()), this, TQ_SLOT(addWP()));
 
     m_btRemove.setText(i18n("&Remove"));
     m_btRemove.setMinimumSize(m_btRemove.sizeHint());
-    connect(&m_btRemove, SIGNAL(clicked()), this, SLOT(removeBP()));
+    connect(&m_btRemove, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeBP()));
 
     // the Enable/Disable button changes its label
     m_btEnaDis.setText(i18n("&Disable"));
@@ -86,15 +86,15 @@ BreakpointTable::BreakpointTable(TQWidget* parent, const char* name) :
 	    size.setHeight(sizeAlt.height());
 	m_btEnaDis.setMinimumSize(size);
     }
-    connect(&m_btEnaDis, SIGNAL(clicked()), this, SLOT(enadisBP()));
+    connect(&m_btEnaDis, TQ_SIGNAL(clicked()), this, TQ_SLOT(enadisBP()));
 
     m_btViewCode.setText(i18n("&View Code"));
     m_btViewCode.setMinimumSize(m_btViewCode.sizeHint());
-    connect(&m_btViewCode, SIGNAL(clicked()), this, SLOT(viewBP()));
+    connect(&m_btViewCode, TQ_SIGNAL(clicked()), this, TQ_SLOT(viewBP()));
 
     m_btConditional.setText(i18n("&Conditional..."));
     m_btConditional.setMinimumSize(m_btConditional.sizeHint());
-    connect(&m_btConditional, SIGNAL(clicked()), this, SLOT(conditionalBP()));
+    connect(&m_btConditional, TQ_SIGNAL(clicked()), this, TQ_SLOT(conditionalBP()));
 
     m_layout.addLayout(&m_listandedit, 10);
     m_layout.addLayout(&m_buttons);
@@ -459,12 +459,12 @@ ConditionalDlg::ConditionalDlg(TQWidget* parent) :
     m_ignoreLabel.setBuddy(&m_ignoreCount);
 
     m_buttonOK.setMinimumSize(100, 30);
-    connect(&m_buttonOK, SIGNAL(clicked()), SLOT(accept()));
+    connect(&m_buttonOK, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
     m_buttonOK.setText(i18n("OK"));
     m_buttonOK.setDefault(true);
 
     m_buttonCancel.setMinimumSize(100, 30);
-    connect(&m_buttonCancel, SIGNAL(clicked()), SLOT(reject()));
+    connect(&m_buttonCancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
     m_buttonCancel.setText(i18n("Cancel"));
 
     m_layout.addLayout(&m_inputs);
diff --git a/kdbg/dbgdriver.cpp b/kdbg/dbgdriver.cpp
index 04c7270..3f9f1f6 100644
--- a/kdbg/dbgdriver.cpp
+++ b/kdbg/dbgdriver.cpp
@@ -36,10 +36,10 @@ DebuggerDriver::DebuggerDriver() :
     // m_promptLastChar and m_promptMinLen must also be set.
 
     // debugger process
-    connect(this, SIGNAL(receivedStdout(TDEProcess*,char*,int)),
-	    SLOT(slotReceiveOutput(TDEProcess*,char*,int)));
-    connect(this, SIGNAL(wroteStdin(TDEProcess*)), SLOT(slotCommandRead(TDEProcess*)));
-    connect(this, SIGNAL(processExited(TDEProcess*)), SLOT(slotExited(TDEProcess*)));
+    connect(this, TQ_SIGNAL(receivedStdout(TDEProcess*,char*,int)),
+	    TQ_SLOT(slotReceiveOutput(TDEProcess*,char*,int)));
+    connect(this, TQ_SIGNAL(wroteStdin(TDEProcess*)), TQ_SLOT(slotCommandRead(TDEProcess*)));
+    connect(this, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(slotExited(TDEProcess*)));
 }
 
 DebuggerDriver::~DebuggerDriver()
diff --git a/kdbg/dbgmainwnd.cpp b/kdbg/dbgmainwnd.cpp
index 06efadd..f1b3089 100644
--- a/kdbg/dbgmainwnd.cpp
+++ b/kdbg/dbgmainwnd.cpp
@@ -84,70 +84,70 @@ DebuggerMainWnd::DebuggerMainWnd(const char* name) :
     initKAction();
     initToolbar(); // kind of obsolete?
 
-    connect(m_watches, SIGNAL(addWatch()), SLOT(slotAddWatch()));
-    connect(m_watches, SIGNAL(deleteWatch()), m_debugger, SLOT(slotDeleteWatch()));
-    connect(m_watches, SIGNAL(textDropped(const TQString&)), SLOT(slotAddWatch(const TQString&)));
-
-    connect(&m_filesWindow->m_findDlg, SIGNAL(closed()), SLOT(updateUI()));
-    connect(m_filesWindow, SIGNAL(newFileLoaded()),
-	    SLOT(slotNewFileLoaded()));
-    connect(m_filesWindow, SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)),
-	    this, SLOT(slotToggleBreak(const TQString&,int,const DbgAddr&,bool)));
-    connect(m_filesWindow, SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)),
-	    this, SLOT(slotEnaDisBreak(const TQString&,int,const DbgAddr&)));
-    connect(m_debugger, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
-	    m_filesWindow, SLOT(activate(const TQString&,int,const DbgAddr&)));
-    connect(m_debugger, SIGNAL(executableUpdated()),
-	    m_filesWindow, SLOT(reloadAllFiles()));
-    connect(m_debugger, SIGNAL(updatePC(const TQString&,int,const DbgAddr&,int)),
-	    m_filesWindow, SLOT(updatePC(const TQString&,int,const DbgAddr&,int)));
+    connect(m_watches, TQ_SIGNAL(addWatch()), TQ_SLOT(slotAddWatch()));
+    connect(m_watches, TQ_SIGNAL(deleteWatch()), m_debugger, TQ_SLOT(slotDeleteWatch()));
+    connect(m_watches, TQ_SIGNAL(textDropped(const TQString&)), TQ_SLOT(slotAddWatch(const TQString&)));
+
+    connect(&m_filesWindow->m_findDlg, TQ_SIGNAL(closed()), TQ_SLOT(updateUI()));
+    connect(m_filesWindow, TQ_SIGNAL(newFileLoaded()),
+	    TQ_SLOT(slotNewFileLoaded()));
+    connect(m_filesWindow, TQ_SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)),
+	    this, TQ_SLOT(slotToggleBreak(const TQString&,int,const DbgAddr&,bool)));
+    connect(m_filesWindow, TQ_SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)),
+	    this, TQ_SLOT(slotEnaDisBreak(const TQString&,int,const DbgAddr&)));
+    connect(m_debugger, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
+	    m_filesWindow, TQ_SLOT(activate(const TQString&,int,const DbgAddr&)));
+    connect(m_debugger, TQ_SIGNAL(executableUpdated()),
+	    m_filesWindow, TQ_SLOT(reloadAllFiles()));
+    connect(m_debugger, TQ_SIGNAL(updatePC(const TQString&,int,const DbgAddr&,int)),
+	    m_filesWindow, TQ_SLOT(updatePC(const TQString&,int,const DbgAddr&,int)));
     // value popup communication
-    connect(m_filesWindow, SIGNAL(initiateValuePopup(const TQString&)),
-	    m_debugger, SLOT(slotValuePopup(const TQString&)));
-    connect(m_debugger, SIGNAL(valuePopup(const TQString&)),
-	    m_filesWindow, SLOT(slotShowValueTip(const TQString&)));
+    connect(m_filesWindow, TQ_SIGNAL(initiateValuePopup(const TQString&)),
+	    m_debugger, TQ_SLOT(slotValuePopup(const TQString&)));
+    connect(m_debugger, TQ_SIGNAL(valuePopup(const TQString&)),
+	    m_filesWindow, TQ_SLOT(slotShowValueTip(const TQString&)));
     // disassembling
-    connect(m_filesWindow, SIGNAL(disassemble(const TQString&, int)),
-	    m_debugger, SLOT(slotDisassemble(const TQString&, int)));
-    connect(m_debugger, SIGNAL(disassembled(const TQString&,int,const std::list<DisassembledCode>&)),
-	    m_filesWindow, SLOT(slotDisassembled(const TQString&,int,const std::list<DisassembledCode>&)));
-    connect(m_filesWindow, SIGNAL(moveProgramCounter(const TQString&,int,const DbgAddr&)),
-	    m_debugger, SLOT(setProgramCounter(const TQString&,int,const DbgAddr&)));
+    connect(m_filesWindow, TQ_SIGNAL(disassemble(const TQString&, int)),
+	    m_debugger, TQ_SLOT(slotDisassemble(const TQString&, int)));
+    connect(m_debugger, TQ_SIGNAL(disassembled(const TQString&,int,const std::list<DisassembledCode>&)),
+	    m_filesWindow, TQ_SLOT(slotDisassembled(const TQString&,int,const std::list<DisassembledCode>&)));
+    connect(m_filesWindow, TQ_SIGNAL(moveProgramCounter(const TQString&,int,const DbgAddr&)),
+	    m_debugger, TQ_SLOT(setProgramCounter(const TQString&,int,const DbgAddr&)));
     // program stopped
-    connect(m_debugger, SIGNAL(programStopped()), SLOT(slotProgramStopped()));
-    connect(&m_backTimer, SIGNAL(timeout()), SLOT(slotBackTimer()));
+    connect(m_debugger, TQ_SIGNAL(programStopped()), TQ_SLOT(slotProgramStopped()));
+    connect(&m_backTimer, TQ_SIGNAL(timeout()), TQ_SLOT(slotBackTimer()));
     // tab width
-    connect(this, SIGNAL(setTabWidth(int)), m_filesWindow, SIGNAL(setTabWidth(int)));
+    connect(this, TQ_SIGNAL(setTabWidth(int)), m_filesWindow, TQ_SIGNAL(setTabWidth(int)));
 
     // connect breakpoint table
-    connect(m_bpTable, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
-	    m_filesWindow, SLOT(activate(const TQString&,int,const DbgAddr&)));
-    connect(m_debugger, SIGNAL(updateUI()), m_bpTable, SLOT(updateUI()));
-    connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateBreakList()));
-    connect(m_debugger, SIGNAL(breakpointsChanged()), m_bpTable, SLOT(updateUI()));
-
-    connect(m_debugger, SIGNAL(registersChanged(const std::list<RegisterInfo>&)),
-	    m_registers, SLOT(updateRegisters(const std::list<RegisterInfo>&)));
-
-    connect(m_debugger, SIGNAL(memoryDumpChanged(const TQString&, const std::list<MemoryDump>&)),
-	    m_memoryWindow, SLOT(slotNewMemoryDump(const TQString&, const std::list<MemoryDump>&)));
-    connect(m_debugger, SIGNAL(saveProgramSpecific(TDEConfigBase*)),
-	    m_memoryWindow, SLOT(saveProgramSpecific(TDEConfigBase*)));
-    connect(m_debugger, SIGNAL(restoreProgramSpecific(TDEConfigBase*)),
-	    m_memoryWindow, SLOT(restoreProgramSpecific(TDEConfigBase*)));
+    connect(m_bpTable, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
+	    m_filesWindow, TQ_SLOT(activate(const TQString&,int,const DbgAddr&)));
+    connect(m_debugger, TQ_SIGNAL(updateUI()), m_bpTable, TQ_SLOT(updateUI()));
+    connect(m_debugger, TQ_SIGNAL(breakpointsChanged()), m_bpTable, TQ_SLOT(updateBreakList()));
+    connect(m_debugger, TQ_SIGNAL(breakpointsChanged()), m_bpTable, TQ_SLOT(updateUI()));
+
+    connect(m_debugger, TQ_SIGNAL(registersChanged(const std::list<RegisterInfo>&)),
+	    m_registers, TQ_SLOT(updateRegisters(const std::list<RegisterInfo>&)));
+
+    connect(m_debugger, TQ_SIGNAL(memoryDumpChanged(const TQString&, const std::list<MemoryDump>&)),
+	    m_memoryWindow, TQ_SLOT(slotNewMemoryDump(const TQString&, const std::list<MemoryDump>&)));
+    connect(m_debugger, TQ_SIGNAL(saveProgramSpecific(TDEConfigBase*)),
+	    m_memoryWindow, TQ_SLOT(saveProgramSpecific(TDEConfigBase*)));
+    connect(m_debugger, TQ_SIGNAL(restoreProgramSpecific(TDEConfigBase*)),
+	    m_memoryWindow, TQ_SLOT(restoreProgramSpecific(TDEConfigBase*)));
 
     // thread window
-    connect(m_debugger, SIGNAL(threadsChanged(const std::list<ThreadInfo>&)),
-	    m_threads, SLOT(updateThreads(const std::list<ThreadInfo>&)));
-    connect(m_threads, SIGNAL(setThread(int)),
-	    m_debugger, SLOT(setThread(int)));
+    connect(m_debugger, TQ_SIGNAL(threadsChanged(const std::list<ThreadInfo>&)),
+	    m_threads, TQ_SLOT(updateThreads(const std::list<ThreadInfo>&)));
+    connect(m_threads, TQ_SIGNAL(setThread(int)),
+	    m_debugger, TQ_SLOT(setThread(int)));
 
     // view menu changes when docking state changes
-    connect(dockManager, SIGNAL(change()), SLOT(updateUI()));
+    connect(dockManager, TQ_SIGNAL(change()), TQ_SLOT(updateUI()));
 
     // popup menu of the local variables window
-    connect(m_localVariables, SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
-	    this, SLOT(slotLocalsPopup(TQListViewItem*, const TQPoint&)));
+    connect(m_localVariables, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
+	    this, TQ_SLOT(slotLocalsPopup(TQListViewItem*, const TQPoint&)));
 
     restoreSettings(kapp->config());
 
@@ -176,39 +176,39 @@ DebuggerMainWnd::~DebuggerMainWnd()
 void DebuggerMainWnd::initKAction()
 {
     // file menu
-    TDEAction* open = KStdAction::open(this, SLOT(slotFileOpen()), 
+    TDEAction* open = KStdAction::open(this, TQ_SLOT(slotFileOpen()), 
                       actionCollection());
     open->setText(i18n("&Open Source..."));
-    KStdAction::close(m_filesWindow, SLOT(slotClose()), actionCollection());
+    KStdAction::close(m_filesWindow, TQ_SLOT(slotClose()), actionCollection());
     (void)new TDEAction(i18n("&Reload Source"), "reload", 0, m_filesWindow, 
-                      SLOT(slotFileReload()), actionCollection(), 
+                      TQ_SLOT(slotFileReload()), actionCollection(), 
                       "file_reload");
     (void)new TDEAction(i18n("&Executable..."), "execopen", 0, this, 
-                      SLOT(slotFileExe()), actionCollection(), 
+                      TQ_SLOT(slotFileExe()), actionCollection(), 
                       "file_executable");
     m_recentExecAction = new TDERecentFilesAction(i18n("Recent E&xecutables"), 0,
-		      this, SLOT(slotRecentExec(const KURL&)),
+		      this, TQ_SLOT(slotRecentExec(const KURL&)),
 		      actionCollection(), "file_executable_recent");
-    (void)new TDEAction(i18n("&Core dump..."), 0, this, SLOT(slotFileCore()),
+    (void)new TDEAction(i18n("&Core dump..."), 0, this, TQ_SLOT(slotFileCore()),
                       actionCollection(), "file_core_dump");
-    KStdAction::quit(kapp, SLOT(closeAllWindows()), actionCollection());
+    KStdAction::quit(kapp, TQ_SLOT(closeAllWindows()), actionCollection());
 
     // settings menu
     (void)new TDEAction(i18n("This &Program..."), 0, this,
-		      SLOT(slotFileProgSettings()), actionCollection(),
+		      TQ_SLOT(slotFileProgSettings()), actionCollection(),
 		      "settings_program");
     (void)new TDEAction(i18n("&Global Options..."), 0, this, 
-                      SLOT(slotFileGlobalSettings()), actionCollection(),
+                      TQ_SLOT(slotFileGlobalSettings()), actionCollection(),
                       "settings_global");
-    KStdAction::keyBindings(this, SLOT(slotConfigureKeys()), actionCollection());
-    KStdAction::showStatusbar(this, SLOT(slotViewStatusbar()), actionCollection());
+    KStdAction::keyBindings(this, TQ_SLOT(slotConfigureKeys()), actionCollection());
+    KStdAction::showStatusbar(this, TQ_SLOT(slotViewStatusbar()), actionCollection());
 
     // view menu
     (void)new TDEToggleAction(i18n("&Find"), "edit-find", CTRL+Key_F, m_filesWindow,
-			    SLOT(slotViewFind()), actionCollection(),
+			    TQ_SLOT(slotViewFind()), actionCollection(),
 			    "view_find");
-    (void)KStdAction::findNext(m_filesWindow, SLOT(slotFindForward()), actionCollection(), "view_findnext");
-    (void)KStdAction::findPrev(m_filesWindow, SLOT(slotFindBackward()), actionCollection(), "view_findprev");
+    (void)KStdAction::findNext(m_filesWindow, TQ_SLOT(slotFindForward()), actionCollection(), "view_findnext");
+    (void)KStdAction::findPrev(m_filesWindow, TQ_SLOT(slotFindBackward()), actionCollection(), "view_findprev");
 
     i18n("Source &code");
     struct { TQString text; TQWidget* w; TQString id; } dw[] = {
@@ -223,82 +223,82 @@ void DebuggerMainWnd::initKAction()
     };
     for (unsigned i = 0; i < sizeof(dw)/sizeof(dw[0]); i++) {
 	KDockWidget* d = dockParent(dw[i].w);
-	(void)new TDEToggleAction(dw[i].text, 0, d, SLOT(changeHideShowState()),
+	(void)new TDEToggleAction(dw[i].text, 0, d, TQ_SLOT(changeHideShowState()),
 			  actionCollection(), dw[i].id.latin1());
     }
 
     
     // execution menu
     TDEAction* a = new TDEAction(i18n("&Run"), "pgmrun", Key_F5, m_debugger, 
-		      SLOT(programRun()), actionCollection(), "exec_run");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+		      TQ_SLOT(programRun()), actionCollection(), "exec_run");
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Step &into"), "pgmstep", Key_F8, m_debugger, 
-                      SLOT(programStep()), actionCollection(), 
+                      TQ_SLOT(programStep()), actionCollection(), 
                       "exec_step_into");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Step &over"), "pgmnext", Key_F10, m_debugger, 
-                      SLOT(programNext()), actionCollection(), 
+                      TQ_SLOT(programNext()), actionCollection(), 
                       "exec_step_over");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Step o&ut"), "pgmfinish", Key_F6, m_debugger,
-                      SLOT(programFinish()), actionCollection(), 
+                      TQ_SLOT(programFinish()), actionCollection(), 
                       "exec_step_out");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Run to &cursor"), Key_F7, this,
-                      SLOT(slotExecUntil()), actionCollection(), 
+                      TQ_SLOT(slotExecUntil()), actionCollection(), 
                       "exec_run_to_cursor");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Step i&nto by instruction"), "pgmstepi", 
-		      SHIFT+Key_F8, m_debugger, SLOT(programStepi()), 
+		      SHIFT+Key_F8, m_debugger, TQ_SLOT(programStepi()), 
 		      actionCollection(), "exec_step_into_by_insn");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     a = new TDEAction(i18n("Step o&ver by instruction"), "pgmnexti", 
-		      SHIFT+Key_F10, m_debugger, SLOT(programNexti()), 
+		      SHIFT+Key_F10, m_debugger, TQ_SLOT(programNexti()), 
 		      actionCollection(), "exec_step_over_by_insn");
-    connect(a, SIGNAL(activated()), this, SLOT(intoBackground()));
+    connect(a, TQ_SIGNAL(activated()), this, TQ_SLOT(intoBackground()));
     (void)new TDEAction(i18n("&Program counter to current line"), 0,
-		      m_filesWindow, SLOT(slotMoveProgramCounter()),
+		      m_filesWindow, TQ_SLOT(slotMoveProgramCounter()),
 		      actionCollection(), "exec_movepc");
     (void)new TDEAction(i18n("&Break"), 0, m_debugger,
-                      SLOT(programBreak()), actionCollection(),
+                      TQ_SLOT(programBreak()), actionCollection(),
                       "exec_break");
     (void)new TDEAction(i18n("&Kill"), 0, m_debugger,
-                      SLOT(programKill()), actionCollection(),
+                      TQ_SLOT(programKill()), actionCollection(),
                       "exec_kill");
     (void)new TDEAction(i18n("Re&start"), 0, m_debugger,
-                      SLOT(programRunAgain()), actionCollection(),
+                      TQ_SLOT(programRunAgain()), actionCollection(),
                       "exec_restart");
     (void)new TDEAction(i18n("A&ttach..."), 0, this,
-                      SLOT(slotExecAttach()), actionCollection(),
+                      TQ_SLOT(slotExecAttach()), actionCollection(),
                       "exec_attach");
     (void)new TDEAction(i18n("&Arguments..."), 0, this,
-                      SLOT(slotExecArgs()), actionCollection(),
+                      TQ_SLOT(slotExecArgs()), actionCollection(),
                       "exec_arguments");
    
     // breakpoint menu
     (void)new TDEAction(i18n("Set/Clear &breakpoint"), "brkpt", Key_F9,
-                      m_filesWindow, SLOT(slotBrkptSet()), actionCollection(),
+                      m_filesWindow, TQ_SLOT(slotBrkptSet()), actionCollection(),
                       "breakpoint_set");
     (void)new TDEAction(i18n("Set &temporary breakpoint"), SHIFT+Key_F9,
-                      m_filesWindow, SLOT(slotBrkptSetTemp()), actionCollection(),
+                      m_filesWindow, TQ_SLOT(slotBrkptSetTemp()), actionCollection(),
                       "breakpoint_set_temporary");
     (void)new TDEAction(i18n("&Enable/Disable breakpoint"), CTRL+Key_F9,
-                      m_filesWindow, SLOT(slotBrkptEnable()), actionCollection(),
+                      m_filesWindow, TQ_SLOT(slotBrkptEnable()), actionCollection(),
                       "breakpoint_enable");
    
     // only in popup menus
     (void)new TDEAction(i18n("Watch Expression"), 0, this,
-                      SLOT(slotLocalsToWatch()), actionCollection(),
+                      TQ_SLOT(slotLocalsToWatch()), actionCollection(),
                       "watch_expression");
     (void)new TDEAction(i18n("Edit Value"), Key_F2, this,
-		      SLOT(slotEditValue()), actionCollection(),
+		      TQ_SLOT(slotEditValue()), actionCollection(),
 		      "edit_value");
 
     // all actions force an UI update
     TQValueList<TDEAction*> actions = actionCollection()->actions();
     TQValueList<TDEAction*>::Iterator it = actions.begin();
     for (; it != actions.end(); ++it) {
-	connect(*it, SIGNAL(activated()), this, SLOT(updateUI()));
+	connect(*it, TQ_SIGNAL(activated()), this, TQ_SLOT(updateUI()));
     }
 
     createGUI("kdbgui.rc");
@@ -308,7 +308,7 @@ void DebuggerMainWnd::initToolbar()
 {
     TDEToolBar* toolbar = toolBar("mainToolBar");
     toolbar->insertAnimatedWidget(ID_STATUS_BUSY,
-	actionCollection()->action("exec_break"), SLOT(activate()),
+	actionCollection()->action("exec_break"), TQ_SLOT(activate()),
 	"pulse", -1);
     toolbar->alignItemRight(ID_STATUS_BUSY, true);
     m_animRunning = false;
@@ -656,8 +656,8 @@ TQString DebuggerMainWnd::createOutputWindow()
 {
     TQString tty = DebuggerMainWndBase::createOutputWindow();
     if (!tty.isEmpty()) {
-	connect(m_outputTermProc, SIGNAL(processExited(TDEProcess*)),
-		SLOT(slotTermEmuExited()));
+	connect(m_outputTermProc, TQ_SIGNAL(processExited(TDEProcess*)),
+		TQ_SLOT(slotTermEmuExited()));
     }
     return tty;
 }
diff --git a/kdbg/debugger.cpp b/kdbg/debugger.cpp
index 6a749f0..54068fe 100644
--- a/kdbg/debugger.cpp
+++ b/kdbg/debugger.cpp
@@ -47,16 +47,16 @@ KDebugger::KDebugger(TQWidget* parent,
 {
     m_envVars.setAutoDelete(true);
 
-    connect(&m_localVariables, SIGNAL(expanded(TQListViewItem*)),
-	    SLOT(slotExpanding(TQListViewItem*)));
-    connect(&m_watchVariables, SIGNAL(expanded(TQListViewItem*)),
-	    SLOT(slotExpanding(TQListViewItem*)));
-    connect(&m_localVariables, SIGNAL(editValueCommitted(VarTree*, const TQString&)),
-	    SLOT(slotValueEdited(VarTree*, const TQString&)));
-    connect(&m_watchVariables, SIGNAL(editValueCommitted(VarTree*, const TQString&)),
-	    SLOT(slotValueEdited(VarTree*, const TQString&)));
+    connect(&m_localVariables, TQ_SIGNAL(expanded(TQListViewItem*)),
+	    TQ_SLOT(slotExpanding(TQListViewItem*)));
+    connect(&m_watchVariables, TQ_SIGNAL(expanded(TQListViewItem*)),
+	    TQ_SLOT(slotExpanding(TQListViewItem*)));
+    connect(&m_localVariables, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)),
+	    TQ_SLOT(slotValueEdited(VarTree*, const TQString&)));
+    connect(&m_watchVariables, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)),
+	    TQ_SLOT(slotValueEdited(VarTree*, const TQString&)));
 
-    connect(&m_btWindow, SIGNAL(highlighted(int)), SLOT(gotoFrame(int)));
+    connect(&m_btWindow, TQ_SIGNAL(highlighted(int)), TQ_SLOT(gotoFrame(int)));
 
     emit updateUI();
 }
@@ -111,19 +111,19 @@ bool KDebugger::debugProgram(const TQString& name,
     }
 
     // wire up the driver
-    connect(driver, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
-	    this, SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)));
-    connect(driver, SIGNAL(processExited(TDEProcess*)), SLOT(gdbExited(TDEProcess*)));
-    connect(driver, SIGNAL(commandReceived(CmdQueueItem*,const char*)),
-	    SLOT(parse(CmdQueueItem*,const char*)));
-    connect(driver, SIGNAL(wroteStdin(TDEProcess*)), SIGNAL(updateUI()));
-    connect(driver, SIGNAL(inferiorRunning()), SLOT(slotInferiorRunning()));
-    connect(driver, SIGNAL(enterIdleState()), SLOT(backgroundUpdate()));
-    connect(driver, SIGNAL(enterIdleState()), SIGNAL(updateUI()));
-    connect(&m_localVariables, SIGNAL(removingItem(VarTree*)),
-	    driver, SLOT(dequeueCmdByVar(VarTree*)));
-    connect(&m_watchVariables, SIGNAL(removingItem(VarTree*)),
-	    driver, SLOT(dequeueCmdByVar(VarTree*)));
+    connect(driver, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)),
+	    this, TQ_SIGNAL(activateFileLine(const TQString&,int,const DbgAddr&)));
+    connect(driver, TQ_SIGNAL(processExited(TDEProcess*)), TQ_SLOT(gdbExited(TDEProcess*)));
+    connect(driver, TQ_SIGNAL(commandReceived(CmdQueueItem*,const char*)),
+	    TQ_SLOT(parse(CmdQueueItem*,const char*)));
+    connect(driver, TQ_SIGNAL(wroteStdin(TDEProcess*)), TQ_SIGNAL(updateUI()));
+    connect(driver, TQ_SIGNAL(inferiorRunning()), TQ_SLOT(slotInferiorRunning()));
+    connect(driver, TQ_SIGNAL(enterIdleState()), TQ_SLOT(backgroundUpdate()));
+    connect(driver, TQ_SIGNAL(enterIdleState()), TQ_SIGNAL(updateUI()));
+    connect(&m_localVariables, TQ_SIGNAL(removingItem(VarTree*)),
+	    driver, TQ_SLOT(dequeueCmdByVar(VarTree*)));
+    connect(&m_watchVariables, TQ_SIGNAL(removingItem(VarTree*)),
+	    driver, TQ_SLOT(dequeueCmdByVar(VarTree*)));
 
     // create the program settings object
     openProgramConfig(name);
diff --git a/kdbg/exprwnd.cpp b/kdbg/exprwnd.cpp
index efbbd3c..a180fab 100644
--- a/kdbg/exprwnd.cpp
+++ b/kdbg/exprwnd.cpp
@@ -761,12 +761,12 @@ ValueEdit::ValueEdit(ExprWnd* parent) :
     setFrame(false);
     hide();
     lower();	// lower the window below scrollbars
-    connect(parent, SIGNAL(selectionChanged()), SLOT(slotSelectionChanged()));
-    connect(parent, SIGNAL(currentChanged(TQListViewItem*)), SLOT(slotSelectionChanged()));
-    connect(parent, SIGNAL(expanded(TQListViewItem*)), SLOT(slotSelectionChanged()));
-    connect(parent, SIGNAL(collapsed(TQListViewItem*)), SLOT(slotSelectionChanged()));
-    connect(this, SIGNAL(done(VarTree*, const TQString&)),
-	    parent, SIGNAL(editValueCommitted(VarTree*, const TQString&)));
+    connect(parent, TQ_SIGNAL(selectionChanged()), TQ_SLOT(slotSelectionChanged()));
+    connect(parent, TQ_SIGNAL(currentChanged(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
+    connect(parent, TQ_SIGNAL(expanded(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
+    connect(parent, TQ_SIGNAL(collapsed(TQListViewItem*)), TQ_SLOT(slotSelectionChanged()));
+    connect(this, TQ_SIGNAL(done(VarTree*, const TQString&)),
+	    parent, TQ_SIGNAL(editValueCommitted(VarTree*, const TQString&)));
 }
 
 ValueEdit::~ValueEdit()
diff --git a/kdbg/mainwndbase.cpp b/kdbg/mainwndbase.cpp
index ef137a3..fd85b6c 100644
--- a/kdbg/mainwndbase.cpp
+++ b/kdbg/mainwndbase.cpp
@@ -55,11 +55,11 @@ WatchWindow::WatchWindow(TQWidget* parent, const char* name, WFlags f) :
     m_watchH.addWidget(&m_watchAdd, 0);
     m_watchH.addWidget(&m_watchDelete, 0);
 
-    connect(&m_watchEdit, SIGNAL(returnPressed()), SIGNAL(addWatch()));
-    connect(&m_watchAdd, SIGNAL(clicked()), SIGNAL(addWatch()));
-    connect(&m_watchDelete, SIGNAL(clicked()), SIGNAL(deleteWatch()));
-    connect(&m_watchVariables, SIGNAL(currentChanged(TQListViewItem*)),
-	    SLOT(slotWatchHighlighted()));
+    connect(&m_watchEdit, TQ_SIGNAL(returnPressed()), TQ_SIGNAL(addWatch()));
+    connect(&m_watchAdd, TQ_SIGNAL(clicked()), TQ_SIGNAL(addWatch()));
+    connect(&m_watchDelete, TQ_SIGNAL(clicked()), TQ_SIGNAL(deleteWatch()));
+    connect(&m_watchVariables, TQ_SIGNAL(currentChanged(TQListViewItem*)),
+	    TQ_SLOT(slotWatchHighlighted()));
 
     m_watchVariables.installEventFilter(this);
     setAcceptDrops(true);
@@ -154,16 +154,16 @@ void DebuggerMainWndBase::setupDebugger(TQWidget* parent,
 {
     m_debugger = new KDebugger(parent, localVars, watchVars, backtrace);
 
-    TQObject::connect(m_debugger, SIGNAL(updateStatusMessage()),
-		     parent, SLOT(slotNewStatusMsg()));
-    TQObject::connect(m_debugger, SIGNAL(updateUI()),
-		     parent, SLOT(updateUI()));
+    TQObject::connect(m_debugger, TQ_SIGNAL(updateStatusMessage()),
+		     parent, TQ_SLOT(slotNewStatusMsg()));
+    TQObject::connect(m_debugger, TQ_SIGNAL(updateUI()),
+		     parent, TQ_SLOT(updateUI()));
 
-    TQObject::connect(m_debugger, SIGNAL(breakpointsChanged()),
-		     parent, SLOT(updateLineItems()));
+    TQObject::connect(m_debugger, TQ_SIGNAL(breakpointsChanged()),
+		     parent, TQ_SLOT(updateLineItems()));
     
-    TQObject::connect(m_debugger, SIGNAL(debuggerStarting()),
-		     parent, SLOT(slotDebuggerStarting()));
+    TQObject::connect(m_debugger, TQ_SIGNAL(debuggerStarting()),
+		     parent, TQ_SLOT(slotDebuggerStarting()));
 }
 
 
diff --git a/kdbg/memwindow.cpp b/kdbg/memwindow.cpp
index 4d2aac2..183aedb 100644
--- a/kdbg/memwindow.cpp
+++ b/kdbg/memwindow.cpp
@@ -63,8 +63,8 @@ MemoryWindow::MemoryWindow(TQWidget* parent, const char* name) :
     m_layout.addWidget(&m_memory, 10);
     m_layout.activate();
 
-    connect(&m_expression, SIGNAL(activated(const TQString&)),
-	    this, SLOT(slotNewExpression(const TQString&)));
+    connect(&m_expression, TQ_SIGNAL(activated(const TQString&)),
+	    this, TQ_SLOT(slotNewExpression(const TQString&)));
 
     // the popup menu
     m_popup.insertItem(i18n("B&ytes"), MDTbyte);
@@ -82,7 +82,7 @@ MemoryWindow::MemoryWindow(TQWidget* parent, const char* name) :
     m_popup.insertItem(i18n("&Floatingpoint"), MDTfloat);
     m_popup.insertItem(i18n("&Strings"), MDTstring);
     m_popup.insertItem(i18n("&Instructions"), MDTinsn);
-    connect(&m_popup, SIGNAL(activated(int)), this, SLOT(slotTypeChange(int)));
+    connect(&m_popup, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotTypeChange(int)));
 
     /*
      * Handle right mouse button. Signal righteButtonClicked cannot be
diff --git a/kdbg/pgmsettings.cpp b/kdbg/pgmsettings.cpp
index 92bc08d..5a19e55 100644
--- a/kdbg/pgmsettings.cpp
+++ b/kdbg/pgmsettings.cpp
@@ -77,7 +77,7 @@ OutputSettings::OutputSettings(TQWidget* parent) :
 
     // there is no simpler way to get to the active button than
     // to connect to a signal
-    connect(m_group, SIGNAL(clicked(int)), SLOT(slotLevelChanged(int)));
+    connect(m_group, TQ_SIGNAL(clicked(int)), TQ_SLOT(slotLevelChanged(int)));
 }
 
 void OutputSettings::setTTYLevel(int l)
diff --git a/kdbg/procattach.cpp b/kdbg/procattach.cpp
index 5ea278f..45c6958 100644
--- a/kdbg/procattach.cpp
+++ b/kdbg/procattach.cpp
@@ -24,10 +24,10 @@ ProcAttachPS::ProcAttachPS(TQWidget* parent) :
 	m_ppidCol(-1)
 {
     m_ps = new TDEProcess;
-    connect(m_ps, SIGNAL(receivedStdout(TDEProcess*, char*, int)),
-	    this, SLOT(slotTextReceived(TDEProcess*, char*, int)));
-    connect(m_ps, SIGNAL(processExited(TDEProcess*)),
-	    this, SLOT(slotPSDone()));
+    connect(m_ps, TQ_SIGNAL(receivedStdout(TDEProcess*, char*, int)),
+	    this, TQ_SLOT(slotTextReceived(TDEProcess*, char*, int)));
+    connect(m_ps, TQ_SIGNAL(processExited(TDEProcess*)),
+	    this, TQ_SLOT(slotPSDone()));
 
     TQIconSet icon = SmallIconSet("clear_left");
     filterClear->setIconSet(icon);
@@ -279,12 +279,12 @@ ProcAttach::ProcAttach(TQWidget* parent) :
     m_processId.setFrame(true);
 
     m_buttonOK.setMinimumSize(100, 30);
-    connect(&m_buttonOK, SIGNAL(clicked()), SLOT(accept()));
+    connect(&m_buttonOK, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
     m_buttonOK.setText(i18n("OK"));
     m_buttonOK.setDefault(true);
 
     m_buttonCancel.setMinimumSize(100, 30);
-    connect(&m_buttonCancel, SIGNAL(clicked()), SLOT(reject()));
+    connect(&m_buttonCancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
     m_buttonCancel.setText(i18n("Cancel"));
 
     m_layout.addWidget(&m_label);
diff --git a/kdbg/regwnd.cpp b/kdbg/regwnd.cpp
index 20c698b..e3cee61 100644
--- a/kdbg/regwnd.cpp
+++ b/kdbg/regwnd.cpp
@@ -435,8 +435,8 @@ RegisterView::RegisterView(TQWidget* parent, const char* name) :
     setAllColumnsShowFocus( true );
     header()->setClickEnabled(false);
 
-    connect(this, SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
-	    SLOT(rightButtonClicked(TQListViewItem*,const TQPoint&,int)));
+    connect(this, TQ_SIGNAL(contextMenuRequested(TQListViewItem*, const TQPoint&, int)),
+	    TQ_SLOT(rightButtonClicked(TQListViewItem*,const TQPoint&,int)));
 
     m_modemenu = new TQPopupMenu(this, "ERROR");
     for (uint i=0; i<sizeof(menuitems)/sizeof(MenuPair); i++) {
@@ -445,7 +445,7 @@ RegisterView::RegisterView(TQWidget* parent, const char* name) :
 	else
 	    m_modemenu->insertItem(i18n(menuitems[i].name), menuitems[i].mode);
     }
-    connect(m_modemenu,SIGNAL(activated(int)),SLOT(slotModeChange(int)));
+    connect(m_modemenu,TQ_SIGNAL(activated(int)),TQ_SLOT(slotModeChange(int)));
     
     new GroupingViewItem(this, "MIPS VU", "^vu.*",
                          RegisterDisplay::bits32|RegisterDisplay::realE);
diff --git a/kdbg/sourcewnd.cpp b/kdbg/sourcewnd.cpp
index bf8558a..b939d11 100644
--- a/kdbg/sourcewnd.cpp
+++ b/kdbg/sourcewnd.cpp
@@ -46,9 +46,9 @@ SourceWindow::SourceWindow(const TQString& fileName, TQWidget* parent, const cha
     setAutoFormatting(AutoNone);
     setTextFormat(PlainText);
     setWordWrap(NoWrap);
-    connect(verticalScrollBar(), SIGNAL(valueChanged(int)),
-	    this, SLOT(update()));
-    connect(this, SIGNAL(cursorPositionChanged(int,int)), this, SLOT(cursorChanged(int)));
+    connect(verticalScrollBar(), TQ_SIGNAL(valueChanged(int)),
+	    this, TQ_SLOT(update()));
+    connect(this, TQ_SIGNAL(cursorPositionChanged(int,int)), this, TQ_SLOT(cursorChanged(int)));
     viewport()->installEventFilter(this);
 
     // add a syntax highlighter
diff --git a/kdbg/threadlist.cpp b/kdbg/threadlist.cpp
index 0c8cfd7..979a0f3 100644
--- a/kdbg/threadlist.cpp
+++ b/kdbg/threadlist.cpp
@@ -45,8 +45,8 @@ ThreadList::ThreadList(TQWidget* parent, const char* name) :
     m_focusIcon = UserIcon("pcinner");
     makeNoFocusIcon();
 
-    connect(this, SIGNAL(currentChanged(TQListViewItem*)),
-	    this, SLOT(slotCurrentChanged(TQListViewItem*)));
+    connect(this, TQ_SIGNAL(currentChanged(TQListViewItem*)),
+	    this, TQ_SLOT(slotCurrentChanged(TQListViewItem*)));
 }
 
 ThreadList::~ThreadList()
diff --git a/kdbg/ttywnd.cpp b/kdbg/ttywnd.cpp
index 4d489f6..734f0ef 100644
--- a/kdbg/ttywnd.cpp
+++ b/kdbg/ttywnd.cpp
@@ -47,7 +47,7 @@ STTY::STTY() :
     {
 	::fcntl(m_masterfd, F_SETFL, O_NDELAY);
 	m_outNotifier = new TQSocketNotifier(m_masterfd, TQSocketNotifier::Read);
-	connect(m_outNotifier, SIGNAL(activated(int)), SLOT(outReceived(int)));
+	connect(m_outNotifier, TQ_SIGNAL(activated(int)), TQ_SLOT(outReceived(int)));
     } else {
 	m_slavetty = TQString();
     }
@@ -169,7 +169,7 @@ TQString TTYWindow::activate()
 	m_tty = 0;
 	return TQString();
     } else {
-	connect(m_tty, SIGNAL(output(char*,int)), SLOT(slotAppend(char*,int)));
+	connect(m_tty, TQ_SIGNAL(output(char*,int)), TQ_SLOT(slotAppend(char*,int)));
 	return ttyName;
     }
 }
@@ -226,7 +226,7 @@ TQPopupMenu* TTYWindow::createPopupMenu(const TQPoint& pos)
 {
     TQPopupMenu* menu = TQTextEdit::createPopupMenu(pos);
     menu->insertSeparator();
-    menu->insertItem(i18n("&Clear"), this, SLOT(slotClear()));
+    menu->insertItem(i18n("&Clear"), this, TQ_SLOT(slotClear()));
     return menu;
 }
 
diff --git a/kdbg/winstack.cpp b/kdbg/winstack.cpp
index eaa463f..5c56937 100644
--- a/kdbg/winstack.cpp
+++ b/kdbg/winstack.cpp
@@ -27,11 +27,11 @@ WinStack::WinStack(TQWidget* parent, const char* name) :
 	m_tabWidth(0)
 {
     connect(&m_findDlg.m_buttonForward,
-	    SIGNAL(clicked()), SLOT(slotFindForward()));
+	    TQ_SIGNAL(clicked()), TQ_SLOT(slotFindForward()));
     connect(&m_findDlg.m_buttonBackward,
-	    SIGNAL(clicked()), SLOT(slotFindBackward()));
+	    TQ_SIGNAL(clicked()), TQ_SLOT(slotFindBackward()));
 
-    connect(this, SIGNAL(setTabWidth(int)), this, SLOT(slotSetTabWidth(int)));
+    connect(this, TQ_SIGNAL(setTabWidth(int)), this, TQ_SLOT(slotSetTabWidth(int)));
 }
 
 WinStack::~WinStack()
@@ -115,19 +115,19 @@ bool WinStack::activatePath(TQString pathName, int lineNo, const DbgAddr& addres
 	addTab(fw, TQFileInfo(pathName).fileName());
 	setTabToolTip(fw, pathName);
 
-	connect(fw, SIGNAL(clickedLeft(const TQString&,int,const DbgAddr&,bool)),
-		SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)));
-	connect(fw, SIGNAL(clickedMid(const TQString&,int,const DbgAddr&)),
-		SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)));
+	connect(fw, TQ_SIGNAL(clickedLeft(const TQString&,int,const DbgAddr&,bool)),
+		TQ_SIGNAL(toggleBreak(const TQString&,int,const DbgAddr&,bool)));
+	connect(fw, TQ_SIGNAL(clickedMid(const TQString&,int,const DbgAddr&)),
+		TQ_SIGNAL(enadisBreak(const TQString&,int,const DbgAddr&)));
 
 	// disassemble code
-	connect(fw, SIGNAL(disassemble(const TQString&, int)),
-		SIGNAL(disassemble(const TQString&, int)));
-	connect(fw, SIGNAL(expanded(int)), SLOT(slotExpandCollapse(int)));
-	connect(fw, SIGNAL(collapsed(int)), SLOT(slotExpandCollapse(int)));
+	connect(fw, TQ_SIGNAL(disassemble(const TQString&, int)),
+		TQ_SIGNAL(disassemble(const TQString&, int)));
+	connect(fw, TQ_SIGNAL(expanded(int)), TQ_SLOT(slotExpandCollapse(int)));
+	connect(fw, TQ_SIGNAL(collapsed(int)), TQ_SLOT(slotExpandCollapse(int)));
 
 	// tab width
-	connect(this, SIGNAL(setTabWidth(int)), fw, SLOT(setTabWidth(int)));
+	connect(this, TQ_SIGNAL(setTabWidth(int)), fw, TQ_SLOT(setTabWidth(int)));
 	fw->setTabWidth(m_tabWidth);
 	fw->setFocusPolicy(TQWidget::WheelFocus);
 
@@ -412,7 +412,7 @@ FindDialog::FindDialog() :
     m_buttonBackward.setMinimumSize(maxSize);
     m_buttonClose.setMinimumSize(maxSize);
 
-    connect(&m_buttonClose, SIGNAL(clicked()), SLOT(reject()));
+    connect(&m_buttonClose, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
 
     m_layout.addWidget(&m_searchText);
     m_layout.addWidget(&m_caseCheck);